diff --git a/.gitattributes b/.gitattributes index cf5cffa2..b867c9f7 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1,2 +1,3 @@ *.bat text eol=crlf -*.cmd text eol=crlf \ No newline at end of file +*.cmd text eol=crlf +webui/dist/** binary \ No newline at end of file diff --git a/.github/workflows/docker-image-dev.yml b/.github/workflows/docker-image-dev.yml new file mode 100644 index 00000000..63fdafee --- /dev/null +++ b/.github/workflows/docker-image-dev.yml @@ -0,0 +1,160 @@ +name: Docker Build and Push (Dev) + +on: + schedule: + - cron: '0 0 * * *' # every day at midnight UTC + # branches: + # - dev + workflow_dispatch: # 允许手动触发工作流 + inputs: + branch: + description: 'Branch to build' + required: false + default: 'dev' + +# Workflow's jobs +jobs: + build-amd64: + name: Build AMD64 Image + runs-on: ubuntu-24.04 + outputs: + digest: ${{ steps.build.outputs.digest }} + steps: + - name: Check out git repository + uses: actions/checkout@v4 + with: + ref: dev + fetch-depth: 0 + + # Clone required dependencies + # - name: Clone maim_message + # run: git clone https://github.com/MaiM-with-u/maim_message maim_message + + - name: Clone lpmm + run: git clone https://github.com/Mai-with-u/MaiMBot-LPMM.git MaiMBot-LPMM + + - name: Set up Docker Buildx + uses: docker/setup-buildx-action@v3 + with: + buildkitd-flags: --debug + + # Log in docker hub + - name: Log in to Docker Hub + uses: docker/login-action@v3 + with: + username: ${{ secrets.DOCKERHUB_USERNAME }} + password: ${{ secrets.DOCKERHUB_TOKEN }} + + # Generate metadata for Docker images + - name: Docker meta + id: meta + uses: docker/metadata-action@v5 + with: + images: ${{ secrets.DOCKERHUB_USERNAME }}/maibot + + # Build and push AMD64 image by digest + - name: Build and push AMD64 + id: build + uses: docker/build-push-action@v5 + with: + context: . + platforms: linux/amd64 + labels: ${{ steps.meta.outputs.labels }} + file: ./Dockerfile + cache-from: type=registry,ref=${{ secrets.DOCKERHUB_USERNAME }}/maibot:dev-amd64-buildcache + cache-to: type=registry,ref=${{ secrets.DOCKERHUB_USERNAME }}/maibot:dev-amd64-buildcache,mode=max + outputs: type=image,name=${{ secrets.DOCKERHUB_USERNAME }}/maibot,push-by-digest=true,name-canonical=true,push=true + build-args: | + BUILD_DATE=$(date -u +'%Y-%m-%dT%H:%M:%SZ') + VCS_REF=${{ github.sha }} + + build-arm64: + name: Build ARM64 Image + runs-on: ubuntu-24.04-arm + outputs: + digest: ${{ steps.build.outputs.digest }} + steps: + - name: Check out git repository + uses: actions/checkout@v4 + with: + ref: dev + fetch-depth: 0 + + # Clone required dependencies + # - name: Clone maim_message + # run: git clone https://github.com/MaiM-with-u/maim_message maim_message + + - name: Clone lpmm + run: git clone https://github.com/Mai-with-u/MaiMBot-LPMM.git MaiMBot-LPMM + + - name: Set up Docker Buildx + uses: docker/setup-buildx-action@v3 + with: + buildkitd-flags: --debug + + # Log in docker hub + - name: Log in to Docker Hub + uses: docker/login-action@v3 + with: + username: ${{ secrets.DOCKERHUB_USERNAME }} + password: ${{ secrets.DOCKERHUB_TOKEN }} + + # Generate metadata for Docker images + - name: Docker meta + id: meta + uses: docker/metadata-action@v5 + with: + images: ${{ secrets.DOCKERHUB_USERNAME }}/maibot + + # Build and push ARM64 image by digest + - name: Build and push ARM64 + id: build + uses: docker/build-push-action@v5 + with: + context: . + platforms: linux/arm64/v8 + labels: ${{ steps.meta.outputs.labels }} + file: ./Dockerfile + cache-from: type=registry,ref=${{ secrets.DOCKERHUB_USERNAME }}/maibot:dev-arm64-buildcache + cache-to: type=registry,ref=${{ secrets.DOCKERHUB_USERNAME }}/maibot:dev-arm64-buildcache,mode=max + outputs: type=image,name=${{ secrets.DOCKERHUB_USERNAME }}/maibot,push-by-digest=true,name-canonical=true,push=true + build-args: | + BUILD_DATE=$(date -u +'%Y-%m-%dT%H:%M:%SZ') + VCS_REF=${{ github.sha }} + + create-manifest: + name: Create Multi-Arch Manifest + runs-on: ubuntu-24.04 + needs: + - build-amd64 + - build-arm64 + steps: + - name: Set up Docker Buildx + uses: docker/setup-buildx-action@v3 + + # Log in docker hub + - name: Log in to Docker Hub + uses: docker/login-action@v3 + with: + username: ${{ secrets.DOCKERHUB_USERNAME }} + password: ${{ secrets.DOCKERHUB_TOKEN }} + + # Generate metadata for Docker images + - name: Docker meta + id: meta + uses: docker/metadata-action@v5 + with: + images: ${{ secrets.DOCKERHUB_USERNAME }}/maibot + tags: | + type=raw,value=dev + type=schedule,pattern=dev-{{date 'YYMMDD'}} + + - name: Create and Push Manifest + run: | + # 为每个标签创建多架构镜像 + for tag in $(echo "${{ steps.meta.outputs.tags }}" | tr '\n' ' '); do + echo "Creating manifest for $tag" + docker buildx imagetools create -t $tag \ + ${{ secrets.DOCKERHUB_USERNAME }}/maibot@${{ needs.build-amd64.outputs.digest }} \ + ${{ secrets.DOCKERHUB_USERNAME }}/maibot@${{ needs.build-arm64.outputs.digest }} + done diff --git a/.github/workflows/docker-image.yml b/.github/workflows/docker-image-main.yml similarity index 88% rename from .github/workflows/docker-image.yml rename to .github/workflows/docker-image-main.yml index 989888b2..3d9b14ab 100644 --- a/.github/workflows/docker-image.yml +++ b/.github/workflows/docker-image-main.yml @@ -1,8 +1,6 @@ -name: Docker Build and Push +name: Docker Build and Push (Main) on: - schedule: - - cron: '0 0 * * *' push: branches: - main @@ -13,6 +11,11 @@ on: - "*.*.*" - "*.*.*-*" workflow_dispatch: # 允许手动触发工作流 + inputs: + branch: + description: 'Branch to build' + required: false + default: 'main' # Workflow's jobs jobs: @@ -25,15 +28,14 @@ jobs: - name: Check out git repository uses: actions/checkout@v4 with: - ref: ${{ github.event_name == 'schedule' && 'dev' || github.ref }} fetch-depth: 0 # Clone required dependencies - - name: Clone maim_message - run: git clone https://github.com/MaiM-with-u/maim_message maim_message + # - name: Clone maim_message + # run: git clone https://github.com/MaiM-with-u/maim_message maim_message - name: Clone lpmm - run: git clone https://github.com/MaiM-with-u/MaiMBot-LPMM.git MaiMBot-LPMM + run: git clone https://github.com/Mai-with-u/MaiMBot-LPMM.git MaiMBot-LPMM - name: Set up Docker Buildx uses: docker/setup-buildx-action@v3 @@ -79,15 +81,14 @@ jobs: - name: Check out git repository uses: actions/checkout@v4 with: - ref: ${{ github.event_name == 'schedule' && 'dev' || github.ref }} fetch-depth: 0 # Clone required dependencies - - name: Clone maim_message - run: git clone https://github.com/MaiM-with-u/maim_message maim_message + # - name: Clone maim_message + # run: git clone https://github.com/MaiM-with-u/maim_message maim_message - name: Clone lpmm - run: git clone https://github.com/MaiM-with-u/MaiMBot-LPMM.git MaiMBot-LPMM + run: git clone https://github.com/Mai-with-u/MaiMBot-LPMM.git MaiMBot-LPMM - name: Set up Docker Buildx uses: docker/setup-buildx-action@v3 @@ -164,4 +165,4 @@ jobs: docker buildx imagetools create -t $tag \ ${{ secrets.DOCKERHUB_USERNAME }}/maibot@${{ needs.build-amd64.outputs.digest }} \ ${{ secrets.DOCKERHUB_USERNAME }}/maibot@${{ needs.build-arm64.outputs.digest }} - done \ No newline at end of file + done diff --git a/.gitignore b/.gitignore index 9db98c1d..debe4266 100644 --- a/.gitignore +++ b/.gitignore @@ -22,8 +22,10 @@ MaiMBot-LPMM *.zip run_bot.bat run_na.bat +run_all_in_wt.bat run.bat log_debug/ +NapCat.Shell.Windows.OneKey run_amds.bat run_none.bat docs-mai/ @@ -33,9 +35,6 @@ message_queue_content.bat message_queue_window.bat message_queue_window.txt queue_update.txt -memory_graph.gml -/src/tools/tool_can_use/auto_create_tool.py -/src/tools/tool_can_use/execute_python_code_tool.py .env .env.* .cursor @@ -46,13 +45,10 @@ config/lpmm_config.toml config/lpmm_config.toml.bak template/compare/bot_config_template.toml template/compare/model_config_template.toml -（测试版）麦麦生成人格.bat -（临时版）麦麦开始学习.bat -src/plugins/utils/statistic.py CLAUDE.md MaiBot-Dashboard/ cloudflare-workers/ - +result.json # Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] @@ -325,6 +321,7 @@ run_pet.bat !/plugins/emoji_manage_plugin !/plugins/take_picture_plugin !/plugins/deep_think +!/plugins/MaiBot_MCPBridgePlugin !/plugins/ChatFrequency/ !/plugins/__init__.py @@ -332,4 +329,5 @@ config.toml interested_rates.txt MaiBot.code-workspace -*.lock \ No newline at end of file +*.lock +actionlint diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md index 98d846ac..f95b6c9b 100644 --- a/CODE_OF_CONDUCT.md +++ b/CODE_OF_CONDUCT.md @@ -71,7 +71,6 @@ 1. **GitHub Issues**: 对于公开的违规行为，可以在相关issue中直接指出 2. **私下联系**: 可以通过GitHub私信联系项目维护者 -3. **邮件联系**: [如果有项目邮箱地址，请在此提供] 所有报告都将得到及时和公正的处理。我们承诺保护报告者的隐私和安全。 diff --git a/EULA.md b/EULA.md index 249c0e48..ebc7a141 100644 --- a/EULA.md +++ b/EULA.md @@ -1,8 +1,9 @@ -# **MaiBot最终用户许可协议** -**版本：V1.1** -**更新日期：2025年7月10日** -**生效日期：2025年3月18日** -**适用的MaiBot版本号：所有版本** +# **MaiBot最终用户许可协议** + +**版本：V1.2** +**更新日期：2025年12月01日** +**生效日期：2025年12月01日** +**适用的MaiBot版本号：所有版本** **2025© MaiBot项目团队** @@ -14,130 +15,120 @@ **1.2** 在运行或使用本项目之前，您**必须阅读并同意本协议的所有条款**。未成年人或其它无/不完全民事行为能力责任人请**在监护人的陪同下**阅读并同意本协议。如果您不同意，则不得运行或使用本项目。在这种情况下，您应立即从您的设备上卸载或删除本项目及其所有副本。 - ## 二、许可授权 ### 源代码许可 + **2.1** 您**了解**本项目的源代码是基于GPLv3（GNU通用公共许可证第三版）开源协议发布的。您**可以自由使用、修改、分发**本项目的源代码，但**必须遵守**GPLv3许可证的要求。详细内容请参阅项目仓库中的LICENSE文件。 -**2.2** 您**了解**本项目的源代码中可能包含第三方开源代码，这些代码的许可证可能与GPLv3许可证不同。您**同意**在使用这些代码时**遵守**相应的许可证要求。 - +**2.2** 您**了解**本项目的源代码中可能包含第三方开源代码，这些代码的许可证可能与GPLv3许可证不同。您**同意**在使用这些代码时**遵守**相应的许可证要求. ### 输入输出内容授权 -**2.3** 您**了解**本项目是使用您的配置信息、提交的指令（以下简称“输入内容”）和生成的内容（以下简称“输出内容”）构建请求发送到第三方API生成回复的机器人项目。 - +**2.4** 您**了解**本项目是使用您的配置信息、提交的指令（以下简称“输入内容”）和生成的内容（以下简称“输出内容”）构建请求发送到第三方生成回复的机器人项目。 **2.4** 您**授权**本项目使用您的输入和输出内容按照项目的隐私政策用于以下行为： - - 调用第三方API生成回复； - - 调用第三方API用于构建本项目专用的存储于您部署或使用的数据库中的知识库和记忆库； - - 收集并记录本项目专用的存储于您部署或使用的设备中的日志； + +- 调用第三方API生成回复； +- 调用第三方API用于构建本项目专用的存储于您使用的数据库中的知识库和记忆库； +- 调用第三方开发的插件系统功能； +- 收集并记录本项目专用的存储于您使用的设备中的日志； **2.4** 您**了解**本项目的源代码中包含第三方API的调用代码，这些API的使用可能受到第三方的服务条款和隐私政策的约束。在使用这些API时，您**必须遵守**相应的服务条款。 **2.5** 项目团队**不对**第三方API的服务质量、稳定性、准确性、安全性负责，亦**不对**第三方API的服务变更、终止、限制等行为负责。 - -### 插件系统授权和责任免责 - -**2.6** 您**了解**本项目包含插件系统功能，允许加载和使用由第三方开发者（非MaiBot核心开发组成员）开发的插件。这些第三方插件可能具有独立的许可证条款和使用协议。 - -**2.7** 您**了解并同意**： - - 第三方插件的开发、维护、分发由其各自的开发者负责，**与MaiBot项目团队无关**； - - 第三方插件的功能、质量、安全性、合规性**完全由插件开发者负责**； - - MaiBot项目团队**仅提供**插件系统的技术框架，**不对**任何第三方插件的内容、行为或后果承担责任； - - 您使用任何第三方插件的风险**完全由您自行承担**； - -**2.8** 在使用第三方插件前，您**应当**： - - 仔细阅读并遵守插件开发者提供的许可证条款和使用协议； - - 自行评估插件的安全性、合规性和适用性； - - 确保插件的使用符合您所在地区的法律法规要求； - - ## 三、用户行为 -**3.1** 您**了解**本项目会将您的配置信息、输入指令和生成内容发送到第三方API，您**不应**在输入指令和生成内容中包含以下内容： - - 涉及任何国家或地区秘密、商业秘密或其他可能会对国家或地区安全或者公共利益造成不利影响的数据； - - 涉及个人隐私、个人信息或其他敏感信息的数据； - - 任何侵犯他人合法权益的内容； - - 任何违反国家或地区法律法规、政策规定的内容； +**3.1** 您**了解**本项目会将您的配置信息、输入指令和生成内容发送到第三方，您**不应**在输入指令和生成内容中包含以下内容： + +- 涉及任何国家或地区秘密、商业秘密或其他可能会对国家或地区安全或者公共利益造成不利影响的数据； +- 涉及个人隐私、个人信息或其他敏感信息的数据； +- 任何侵犯他人合法权益的内容； +- 任何违反国家或地区法律法规、政策规定的内容； **3.2** 您**不应**将本项目用于以下用途： - - 违反任何国家或地区法律法规、政策规定的行为； + +- 违反任何国家或地区法律法规、政策规定的行为； **3.3** 您**应当**自行确保您被存储在本项目的知识库、记忆库和日志中的输入和输出内容的合法性与合规性以及存储行为的合法性与合规性。您需**自行承担**由此产生的任何法律责任。 **3.4** 对于第三方插件的使用，您**不应**： - - 使用可能存在安全漏洞、恶意代码或违法内容的插件； - - 通过插件进行任何违反法律法规的行为； - - 将插件用于侵犯他人权益或危害系统安全的用途； -**3.5** 您**承诺**对使用第三方插件的行为及其后果承担**完全责任**，包括但不限于因插件缺陷、恶意行为或不当使用造成的任何损失或法律纠纷。 +- 安装、使用任何来源不明或未经验证的第三方插件； +- 使用任何违反法律法规、政策规定或第三方平台规则的第三方插件； +**3.5** 您**应当**自行确保您安装和使用的第三方插件的合法性与合规性以及安装和使用行为的合法性与合规性。您需**自行承担**由此产生的任何法律责任。 +**3.6** 由于本项目会将您的输入指令和生成内容发送到第三方，当您将本项目用于第三方交流环境（如与除您以外的人私聊、群聊、论坛、直播等）时，您**应当**事先明确告知其他交流参与者本项目的使用情况，包括但不限于： + +- 本项目的输出内容是由人工智能生成的； +- 本项目会将交流内容发送到第三方； +- 本项目的隐私政策和用户行为要求； + +您需**自行承担**由此产生的任何后果和法律责任。 + +**3.7** 项目团队**不鼓励**也**不支持**将本项目用于商业用途，但若您确实需要将本项目用于商业用途，您**应当**标明项目地址（如“本项目由MaiBot()驱动”），并**自行承担**由此产生的任何法律责任。 ## 四、免责条款 **4.1** 本项目的输出内容依赖第三方API，**不受**项目团队控制，亦**不代表**项目团队的观点。 -**4.2** 除本协议条目2.4提到的隐私政策之外，项目团队**不会**对您提供任何形式的担保，亦**不对**使用本项目的造成的任何后果负责。 +**4.2** 除本协议条目2.4提到的隐私政策之外，项目团队**不会**对您提供任何形式的担保，亦**不对**使用本项目的造成的任何直接或间接后果负责。 -**4.3** 关于第三方插件，项目团队**明确声明**： - - 项目团队**不对**任何第三方插件的功能、安全性、稳定性、合规性或适用性提供任何形式的保证或担保； - - 项目团队**不对**因使用第三方插件而产生的任何直接或间接损失、数据丢失、系统故障、安全漏洞、法律纠纷或其他后果承担责任； - - 第三方插件的质量问题、技术支持、bug修复等事宜应**直接联系插件开发者**，与项目团队无关； - - 项目团队**保留**在不另行通知的情况下，对插件系统功能进行修改、限制或移除的权利； +**4.3** 关于第三方插件，项目团队**声明**： + +- 项目团队**不对**任何第三方插件的功能、安全性、稳定性、合规性或适用性提供任何形式的保证或担保； +- 项目团队**不对**因使用第三方插件而产生的任何直接或间接后果承担责任； +- 项目团队**不对**第三方插件的质量问题、技术支持、bug修复等事宜负责。如有相关问题，应**直接联系插件开发者**； ## 五、其他条款 -**5.1** 项目团队有权**随时修改本协议的条款**，但**没有**义务通知您。修改后的协议将在本项目的新版本中生效，您应定期检查本协议的最新版本。 +**5.1** 项目团队有权**随时修改本协议的条款**，但**无义务**通知您。修改后的协议将在本项目的新版本中推送，您应定期检查本协议的最新版本。 **5.2** 项目团队**保留**本协议的最终解释权。 - ## 附录：其他重要须知 -### 一、过往版本使用条件追溯 +### 一、风险提示 -**1.1** 对于本项目此前未配备 EULA 协议的版本，自本协议发布之日起，若用户希望继续使用本项目，应在本协议生效后的合理时间内，通过升级到最新版本并同意本协议全部条款。若在本版协议生效日（2025年3月18日）之后，用户仍使用此前无 EULA 协议的项目版本且未同意本协议，则用户无权继续使用，项目方有权采取措施阻止其使用行为，并保留追究相关法律责任的权利。 +**1.1** 隐私安全风险 +- 本项目会将您的配置信息、输入指令和生成内容发送到第三方API，而这些API的服务质量、稳定性、准确性、安全性不受项目团队控制。 +- 本项目会收集您的输入和输出内容，用于构建本项目专用的知识库和记忆库，以提高回复的准确性和连贯性。 -### 二、风险提示 +**因此，为了保障您的隐私信息安全，请注意以下事项：** -**2.1 隐私安全风险** +- 避免在涉及个人隐私、个人信息或其他敏感信息的环境中使用本项目； +- 避免在不可信的环境中使用本项目； - - 本项目会将您的配置信息、输入指令和生成内容发送到第三方API，而这些API的服务质量、稳定性、准确性、安全性不受项目团队控制。 - - 本项目会收集您的输入和输出内容，用于构建本项目专用的知识库和记忆库，以提高回复的准确性和连贯性。 - - **因此，为了保障您的隐私信息安全，请注意以下事项：** - - - 避免在涉及个人隐私、个人信息或其他敏感信息的环境中使用本项目； - - 避免在不可信的环境中使用本项目； - -**2.2 精神健康风险** +**1.2** 精神健康风险 本项目仅为工具型机器人，不具备情感交互能力。建议用户： - - 避免过度依赖AI回复处理现实问题或情绪困扰； - - 如感到心理不适，请及时寻求专业心理咨询服务。 - - 如遇心理困扰，请寻求专业帮助（全国心理援助热线：12355）。 -**2.3 第三方插件风险** +- 避免过度依赖AI回复处理现实问题或情绪困扰； +- 如感到心理不适，请及时寻求专业心理咨询服务； +- 如遇心理困扰，请寻求专业帮助（全国心理援助热线：12355）； + +**1.3** 第三方插件风险 本项目的插件系统允许加载第三方开发的插件，这可能带来以下风险： - - **安全风险**：第三方插件可能包含恶意代码、安全漏洞或未知的安全威胁； - - **稳定性风险**：插件可能导致系统崩溃、性能下降或功能异常； - - **隐私风险**：插件可能收集、传输或泄露您的个人信息和数据； - - **合规风险**：插件的功能或行为可能违反相关法律法规或平台规则； - - **兼容性风险**：插件可能与主程序或其他插件产生冲突； - **因此，在使用第三方插件时，请务必：** +- **安全风险**：第三方插件可能包含恶意代码、安全漏洞或未知的安全威胁； +- **稳定性风险**：插件可能导致系统崩溃、性能下降或功能异常； +- **隐私风险**：插件可能收集、传输或泄露您的个人信息和数据； +- **合规风险**：插件的功能或行为可能违反相关法律法规或平台规则； +- **兼容性风险**：插件可能与主程序或其他插件产生冲突； - - 仅从可信来源获取和安装插件； - - 在安装前仔细了解插件的功能、权限和开发者信息； - - 定期检查和更新已安装的插件； - - 如发现插件异常行为，请立即停止使用并卸载； - - 对插件的使用后果承担完全责任； +**因此，在使用第三方插件时，请务必：** -### 三、其他 -**3.1 争议解决** - - 本协议适用中国法律，争议提交相关地区法院管辖； - - 若因GPLv3许可产生纠纷，以许可证官方解释为准。 +- 仅从可信来源获取和安装插件； +- 在安装前仔细了解插件的功能、权限和开发者信息； +- 定期检查和更新已安装的插件； +- 如发现插件异常行为，请立即停止使用并卸载； + +### 二、其他 + +**2.1** 争议解决 + +- 本协议适用中国法律，争议提交相关地区法院管辖； +- 若因GPLv3许可产生纠纷，以许可证官方解释为准。 diff --git a/README.md b/README.md index de5b2e28..3ee493c2 100644 --- a/README.md +++ b/README.md @@ -46,16 +46,20 @@ ## 🔥 更新和安装 -**最新版本: v0.11.5** ([更新日志](changelogs/changelog.md)) +**最新版本: v0.11.6** ([更新日志](changelogs/changelog.md)) 可前往 [Release](https://github.com/MaiM-with-u/MaiBot/releases/) 页面下载最新版本 + 可前往 [启动器发布页面](https://github.com/MaiM-with-u/mailauncher/releases/)下载最新启动器 + +注意，启动器处于早期开发版本，仅支持MacOS + **GitHub 分支说明：** - `main`: 稳定发布版本(推荐) - - `dev`: 开发测试版本(不稳定) + - `classical`: 经典版本(停止维护) ### 最新版本部署教程 @@ -69,18 +73,23 @@ ## 💬 讨论 -**技术交流群：** +**技术交流群/答疑群：** [麦麦脑电图](https://qm.qq.com/q/RzmCiRtHEW) | - [麦麦脑磁图](https://qm.qq.com/q/wlH5eT8OmQ) | [麦麦大脑磁共振](https://qm.qq.com/q/VQ3XZrWgMs) | - [麦麦要当VTB](https://qm.qq.com/q/wGePTl1UyY) + [麦麦要当VTB](https://qm.qq.com/q/wGePTl1UyY) | + + 为了维持技术交流和互帮互助的氛围，请不要在技术交流群讨论过多无关内容~ **聊天吹水群：** - [麦麦之闲聊群](https://qm.qq.com/q/JxvHZnxyec) + 麦麦相关闲聊群，此群仅用于聊天，提问部署/技术问题可能不会快速得到答案 + **插件开发/测试版讨论群：** - [插件开发群](https://qm.qq.com/q/1036092828) + 进阶内容，包括插件开发，测试版使用等等 + ## 📚 文档 **部分内容可能更新不够及时，请注意版本对应** diff --git a/bot.py b/bot.py index 68c6e110..35e1ded1 100644 --- a/bot.py +++ b/bot.py @@ -5,16 +5,22 @@ import time import platform import traceback import shutil +import sys +import subprocess from dotenv import load_dotenv from pathlib import Path from rich.traceback import install +from src.common.logger import initialize_logging, get_logger, shutdown_logging + +# 设置工作目录为脚本所在目录 +script_dir = os.path.dirname(os.path.abspath(__file__)) +os.chdir(script_dir) 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: try: if template_env_path.exists(): @@ -28,23 +34,93 @@ else: print(f"自动创建 .env 失败: {e}") raise -# 最早期初始化日志系统，确保所有后续模块都使用正确的日志格式 -from src.common.logger import initialize_logging, get_logger, shutdown_logging # noqa +# 检查是否是 Worker 进程，只在 Worker 进程中输出详细的初始化信息 +# Runner 进程只需要基本的日志功能，不需要详细的初始化日志 +is_worker = os.environ.get("MAIBOT_WORKER_PROCESS") == "1" +initialize_logging(verbose=is_worker) +install(extra_lines=3) +logger = get_logger("main") -initialize_logging() +# 定义重启退出码 +RESTART_EXIT_CODE = 42 + + +def run_runner_process(): + """ + Runner 进程逻辑：作为守护进程运行，负责启动和监控 Worker 进程。 + 处理重启请求 (退出码 42) 和 Ctrl+C 信号。 + """ + script_file = sys.argv[0] + python_executable = sys.executable + + # 设置环境变量，标记子进程为 Worker 进程 + env = os.environ.copy() + env["MAIBOT_WORKER_PROCESS"] = "1" + + while True: + logger.info(f"正在启动 {script_file}...") + + # 启动子进程 (Worker) + # 使用 sys.executable 确保使用相同的 Python 解释器 + cmd = [python_executable, script_file] + sys.argv[1:] + + process = subprocess.Popen(cmd, env=env) + + try: + # 等待子进程结束 + return_code = process.wait() + + if return_code == RESTART_EXIT_CODE: + logger.info("检测到重启请求 (退出码 42)，正在重启...") + time.sleep(1) # 稍作等待 + continue + else: + logger.info(f"程序已退出 (退出码 {return_code})") + sys.exit(return_code) + + except KeyboardInterrupt: + # 向子进程发送终止信号 + if process.poll() is None: + # 在 Windows 上，Ctrl+C 通常已经发送给了子进程（如果它们共享控制台） + # 但为了保险，我们可以尝试 terminate + try: + process.terminate() + process.wait(timeout=5) + except subprocess.TimeoutExpired: + logger.warning("子进程未响应，强制关闭...") + process.kill() + sys.exit(0) + + +# 检查是否是 Worker 进程 +# 如果没有设置 MAIBOT_WORKER_PROCESS 环境变量，说明是直接运行的脚本， +# 此时应该作为 Runner 运行。 +if os.environ.get("MAIBOT_WORKER_PROCESS") != "1": + if __name__ == "__main__": + run_runner_process() + # 如果作为模块导入，不执行 Runner 逻辑，但也不应该执行下面的 Worker 逻辑 + sys.exit(0) + +# 以下是 Worker 进程的逻辑 + +# 最早期初始化日志系统，确保所有后续模块都使用正确的日志格式 +# 注意：Runner 进程已经在第 37 行初始化了日志系统，但 Worker 进程是独立进程，需要重新初始化 +# 由于 Runner 和 Worker 是不同进程，它们有独立的内存空间，所以都会初始化一次 +# 这是正常的，但为了避免重复的初始化日志，我们在 initialize_logging() 中添加了防重复机制 +# 不过由于是不同进程，每个进程仍会初始化一次，这是预期的行为 from src.main import MainSystem # noqa from src.manager.async_task_manager import async_task_manager # noqa -logger = get_logger("main") +# logger = get_logger("main") -install(extra_lines=3) +# install(extra_lines=3) # 设置工作目录为脚本所在目录 -script_dir = os.path.dirname(os.path.abspath(__file__)) -os.chdir(script_dir) +# script_dir = os.path.dirname(os.path.abspath(__file__)) +# os.chdir(script_dir) logger.info(f"已设置工作目录为: {script_dir}") @@ -58,6 +134,33 @@ app = None loop = None +def print_opensource_notice(): + """打印开源项目提示，防止倒卖""" + from colorama import init, Fore, Style + + init() + + notice_lines = [ + "", + f"{Fore.CYAN}{'═' * 70}{Style.RESET_ALL}", + f"{Fore.GREEN} ★ MaiBot - 开源 AI 聊天机器人 ★{Style.RESET_ALL}", + f"{Fore.CYAN}{'─' * 70}{Style.RESET_ALL}", + f"{Fore.YELLOW} 本项目是完全免费的开源软件，基于 GPL-3.0 协议发布{Style.RESET_ALL}", + f"{Fore.WHITE} 如果有人向你「出售本软件」，你被骗了！{Style.RESET_ALL}", + "", + f"{Fore.WHITE} 官方仓库: {Fore.BLUE}https://github.com/MaiM-with-u/MaiBot {Style.RESET_ALL}", + f"{Fore.WHITE} 官方文档: {Fore.BLUE}https://docs.mai-mai.org {Style.RESET_ALL}", + f"{Fore.WHITE} 官方群聊: {Fore.BLUE}1006149251{Style.RESET_ALL}", + f"{Fore.CYAN}{'─' * 70}{Style.RESET_ALL}", + f"{Fore.RED} ⚠ 将本软件作为「商品」倒卖、隐瞒开源性质均违反协议！{Style.RESET_ALL}", + f"{Fore.CYAN}{'═' * 70}{Style.RESET_ALL}", + "", + ] + + for line in notice_lines: + print(line) + + def easter_egg(): # 彩蛋 from colorama import init, Fore @@ -78,6 +181,7 @@ async def graceful_shutdown(): # sourcery skip: use-named-expression # 关闭 WebUI 服务器 try: from src.webui.webui_server import get_webui_server + webui_server = get_webui_server() if webui_server and webui_server._server: await webui_server.shutdown() @@ -202,6 +306,9 @@ def raw_main(): if platform.system().lower() != "windows": time.tzset() # type: ignore + # 打印开源提示（防止倒卖） + print_opensource_notice() + check_eula() logger.info("检查EULA和隐私条款完成") @@ -235,15 +342,33 @@ if __name__ == "__main__": loop.run_until_complete(main_tasks) except KeyboardInterrupt: - # loop.run_until_complete(get_global_api().stop()) logger.warning("收到中断信号，正在优雅关闭...") + + # 取消主任务 + if "main_tasks" in locals() and main_tasks and not main_tasks.done(): + main_tasks.cancel() + try: + loop.run_until_complete(main_tasks) + except asyncio.CancelledError: + pass + + # 执行优雅关闭 if loop and not loop.is_closed(): try: loop.run_until_complete(graceful_shutdown()) - except Exception as ge: # 捕捉优雅关闭时可能发生的错误 + except Exception as ge: logger.error(f"优雅关闭时发生错误: {ge}") # 新增：检测外部请求关闭 + except SystemExit as e: + # 捕获 SystemExit (例如 sys.exit()) 并保留退出代码 + if isinstance(e.code, int): + exit_code = e.code + else: + exit_code = 1 if e.code else 0 + if exit_code == RESTART_EXIT_CODE: + logger.info("收到重启信号，准备退出并请求重启...") + except Exception as e: logger.error(f"主程序发生异常: {str(e)} {str(traceback.format_exc())}") exit_code = 1 # 标记发生错误 diff --git a/changelogs/changelog.md b/changelogs/changelog.md index 0a4f34b9..11545b58 100644 --- a/changelogs/changelog.md +++ b/changelogs/changelog.md @@ -1,4 +1,68 @@ # Changelog + +## [0.12.0] - 2025-12-16 +### 🌟 重大更新 +- 添加思考力度机制，动态控制回复时间和长度 +- planner和replyer现在开启联动，更好的回复逻辑 +- 新的私聊系统，吸收了pfc的优秀机制 +- 增加麦麦做梦功能 +- mcp插件作为内置插件加入，默认不启用 +- 添加全局记忆配置项，现在可以选择让记忆为全局的 + +### 细节功能更改 +- 移除频率自动调整 +- 移除情绪功能 +- 优化记忆差许多呢超时设置 +- 部分配置为0的bug +- 黑话和表达不再提取包含名称的内容 + +## [0.11.6] - 2025-12-2 +### 🌟 重大更新 +- 大幅提高记忆检索能力，略微提高token消耗 +- 重构历史消息概括器，更好的主题记忆 +- 日志查看器性能革命性优化 +- 支持可视化查看麦麦LPMM知识图谱 +- 支持根据不同的模型提供商/模板/URL自动获取模型，可以不用手动输入模型了 +- 新增Baka引导系统，使用React-JoyTour实现很棒的用户引导系统（让Baka也能看懂！） +- 本地聊天室功能！！你可以直接在WebUI网页和麦麦聊天！！ +- 使用cookie模式替换原有的LocalStorage Token存储，可能需要重新手动输入一遍Token +- WebUI本地聊天室支持用户模拟和平台模拟的功能！ +- WebUI新增黑话管理 & 编辑界面 + +### 细节功能更改 +- 可选记忆识别中是否启用jargon +- 解耦表情包识别和图片识别 +- 修复部分破损json的解析问题 +- 黑话更高的提取效率，增加提取准确性 +- 升级jargon，更快更精准 +- 新增Lpmm可视化 + +### webui细节更新 +- 修复侧边栏收起、UI及表格横向滚动等问题，优化Toast动画 +- 修复适配器配置、插件克隆、表情包注册等相关BUG +- 新增适配器/模型预设模式及模板，自动填写URL和类型 +- 支持模型任务列表拖拽排序 +- 更新重启弹窗和首次引导内容 +- 多处界面命名及标题优化，如模型配置相关菜单重命名和描述更新 +- 修复聊天配置“提及回复”相关开关命名错误 +- 调试配置新增“显示记忆/Planner/LPMM Prompt”选项 +- 新增卡片尺寸、排序、字号、行间距等个性化功能 +- 聊天ID及群聊选择优化，显示可读名称 +- 聊天编辑界面精简字段，新增后端聊天列表API支持 +- 默认行间距减小，显示更紧凑 +- 修复页面滚动、表情包排序、发言频率为0等问题 +- 新增React异常Traceback界面及模型列表搜索 +- 更新WebUI Icon，修复适配器docker路径等问题 +- 插件配置可视化编辑，表单控件/元数据/布局类型扩展 +- 新增插件API与开发文档 +- 新增机器人状态卡片和快速操作按钮 +- 调整饼图显示、颜色算法，修复部分统计及解析错误 +- 新增缓存、WebSocket配置 +- 表情包支持上传和缩略图 +- 修复首页极端加载、重启后CtrlC失效、主程序配置移动端适配等问题 +- 新增表达反思设置和WebUI聊天室“思考中”占位组件 +- 细节如移除部分字段或UI控件、优化按钮/弹窗/编辑逻辑等 + ## [0.11.5] - 2025-11-21 ### 🌟 重大更新 - WebUI 现支持手动重启麦麦，曲线救国版“热重载” diff --git a/docker-compose.yml b/docker-compose.yml index 29887250..06124848 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -27,7 +27,7 @@ services: # image: infinitycat/maibot:dev environment: - TZ=Asia/Shanghai -# - EULA_AGREE=99f08e0cab0190de853cb6af7d64d4de # 同意EULA +# - EULA_AGREE=1b662741904d7155d1ce1c00b3530d0d # 同意EULA # - PRIVACY_AGREE=9943b855e72199d0f5016ea39052f1b6 # 同意EULA ports: - "18001:8001" # webui端口 @@ -35,11 +35,12 @@ services: volumes: - ./docker-config/mmc/.env:/MaiMBot/.env # 持久化env配置文件 - ./docker-config/mmc:/MaiMBot/config # 持久化bot配置文件 + - ./docker-config/adapters:/MaiMBot/adapters-config # adapter配置文件夹映射 - ./data/MaiMBot/maibot_statistics.html:/MaiMBot/maibot_statistics.html #统计数据输出 - ./data/MaiMBot:/MaiMBot/data # 共享目录 - ./data/MaiMBot/plugins:/MaiMBot/plugins # 插件目录 - ./data/MaiMBot/logs:/MaiMBot/logs # 日志目录 - - site-packages:/usr/local/lib/python3.13/site-packages # 持久化Python包 + # - site-packages:/usr/local/lib/python3.13/site-packages # 持久化Python包，需要时启用 restart: always networks: - maim_bot @@ -86,8 +87,8 @@ services: # networks: # - maim_bot -volumes: - site-packages: +# volumes: # 若需要持久化Python包时启用 +# site-packages: networks: maim_bot: driver: bridge diff --git a/docs-src/lpmm_parameters_guide.md b/docs-src/lpmm_parameters_guide.md new file mode 100644 index 00000000..5d190589 --- /dev/null +++ b/docs-src/lpmm_parameters_guide.md @@ -0,0 +1,156 @@ +# LPMM 关键参数调节指南（进阶版） + +> 本文是对 `config/bot_config.toml` 中 `[lpmm_knowledge]` 段的补充说明。 +> 如果你只想使用默认配置，可以不改这些参数，脚本仍然可以正常工作。 +> +> 重要提醒：无论是修改 `[lpmm_knowledge]` 段的参数，还是通过脚本导入 / 删除 LPMM 知识库数据，主程序都需要重启（或在内部调用一次 `lpmm_start_up()`）后，新的参数和知识才会真正生效到聊天侧。 + +所有与 LPMM 相关的参数，都集中在： + +```toml +[lpmm_knowledge] # lpmm知识库配置 +enable = true +lpmm_mode = "agent" +... +``` + +下面按功能将常用参数分为三组介绍。 + +--- + +## 一、检索相关参数（影响答案质量与风格） + +```toml +qa_relation_search_top_k = 10 # 关系检索TopK +qa_relation_threshold = 0.5 # 关系阈值，相似度高于该值才认为“命中关系” +qa_paragraph_search_top_k = 1000 # 段落检索TopK，越小可能影响召回 +qa_paragraph_node_weight = 0.05 # 段落节点权重，在图检索&PPR中的权重 +qa_ent_filter_top_k = 10 # 实体过滤TopK +qa_ppr_damping = 0.8 # PPR阻尼系数 +qa_res_top_k = 3 # 最终提供给问答模型的段落数 +``` + +- `qa_relation_search_top_k` + 控制“最多考虑多少条关系向量候选”。 + - 数值大：召回更全面，但略慢； + - 数值小：更快，可能遗漏部分隐含关系。 + +- `qa_relation_threshold` + 关系相似度的阈值： + - 数值高：只信任非常相关的关系，系统更可能退化为纯段落向量检索； + - 数值低：图结构影响更大，适合实体关系较丰富的场景。 + +- `qa_paragraph_search_top_k` + 控制“最多考虑多少段落候选”。 + - 太小：可能召回不全，导致答案缺失； + - 太大：略微增加计算量，一般 1000 为安全默认。 + +- `qa_paragraph_node_weight` + 文段节点在图检索中的权重： + - 数值大：更依赖段落向量相似度（传统向量检索）； + - 数值小：更依赖图结构和实体网络。 + +- `qa_ppr_damping` + Personalized PageRank 的阻尼系数： + - 通常保持在 0.8 左右即可； + - 越接近 1：偏向长路径探索，结果更发散； + - 略低：更集中在与问题直接相关的节点附近。 + +- `qa_res_top_k` + LPMM 最终会把相关度最高的前 `qa_res_top_k` 条段落组合成“知识上下文”给问答模型。 + - 太多：增加模型负担、阅读更多文字； + - 太少：信息不够充分，一般 3–5 比较平衡。 + +> 调参建议： +> - 优先在 `qa_relation_threshold`、`qa_paragraph_node_weight` 上做小幅调整； +> - 每次调整后，用 `scripts/test_lpmm_retrieval.py` 跑一遍固定问题，感受回答变化。 + +--- + +## 二、性能与硬件相关参数 + +```toml +embedding_dimension = 1024 # 嵌入向量维度,应与模型输出维度一致 +max_embedding_workers = 12 # 嵌入/抽取并发线程数 +embedding_chunk_size = 16 # 每批嵌入的条数 +info_extraction_workers = 3 # 实体抽取同时执行线程数 +enable_ppr = true # 是否启用PPR，低配机器可关闭 +``` + +- `embedding_dimension` + 必须与所选嵌入模型的输出维度一致（比如 768、1024 等）。**不要随意修改，除非你知道你在做什么！！！** + +- `max_embedding_workers` + 决定导入/抽取阶段的并行线程数： + - 机器配置好：可以适当调大，加快导入速度； + - 机器配置弱：建议调低（如 2 或 4），避免 CPU 长时间 100%。 + +- `embedding_chunk_size` + 每批发送给嵌入 API 的段落数量： + - 数值大：请求次数少，但单次请求更“重”； + - 数值小：请求次数多，但对网络和 API 的单次压力小。 + +- `info_extraction_workers` + `scripts/info_extraction.py` 中实体抽取的并行线程数： + - 使用 Pro/贵价模型时建议不要太大，避免并行费用过高； + - 一般 2–4 就能取得较好平衡。 + +- `enable_ppr` + 是否启用个性化 PageRank（PPR）图检索： + - `true`：检索会结合向量+知识图，效果更好，但略慢； + - `false`：只用向量检索，牺牲一定效果，性能更稳定。 + + +> 调参建议： +> - 若导入/检索阶段机器明显“顶不住”（>=1MB的大文本，且分配配置<4C），优先调低： +> - `max_embedding_workers` +> - `embedding_chunk_size` +> - `info_extraction_workers` +> - 或暂时将 `enable_ppr = false` （除非真的出现问题，否则不建议禁用此项，大幅影响检索效果） +> - 调整后重新执行导入或检索，观察日志与系统资源占用。 + +> 小提示：每次大改参数或批量删除知识后，建议用 +> - `scripts/test_lpmm_retrieval.py` 看回答风格是否如预期； +> - 如需确认当前磁盘数据能否正常初始化，可执行 `scripts/refresh_lpmm_knowledge.py` 做一次快速自检。 + +--- + +## 三、开启/关闭 LPMM 与模式说明 + +```toml +enable = true # 是否开启lpmm知识库 +lpmm_mode = "agent" # 可选 classic / agent +``` + +- `enable` + - `true`：LPMM 知识库启用，检索和问答会使用知识库； + - `false`：LPMM 完全关闭，脚本仍可导入/删除数据，但对聊天问答不生效。 + +- `lpmm_mode` + - `classic`：传统模式，仅使用 LPMM 知识库本身； + - `agent`：与新的记忆系统联动，用于更复杂的记忆+知识混合场景。 + +> 修改 `enable` 或 `lpmm_mode` 后，需要重启主程序，让配置生效。 + +--- + +## 四、推荐的调参流程 + +1. **保持默认配置，先跑一轮完整流程** + - 导入 → `inspect_lpmm_global.py` → `test_lpmm_retrieval.py`； + - 记录当前“答案风格”和“响应速度”。 + +2. **每次只调整一到两个参数** + - 例如先调 `qa_relation_threshold`、`qa_paragraph_node_weight`； + - 或在性能不佳时调整 `max_embedding_workers`、`enable_ppr`。 + +3. **调整后重复同一组测试问题** + - 使用 `scripts/test_lpmm_retrieval.py`； + - 对比不同配置下的答案，选择更符合需求的组合。 + +4. **出现“怎么调都不对”时** + - 将 `[lpmm_knowledge]` 段恢复为仓库中的默认配置； + - 重启主程序，即可回到“出厂设置”。 + +通过本指南中的参数调节，你可以在“检索质量”“响应速度”“系统资源占用”之间找到适合自己麦麦和机器的平衡点！ + diff --git a/docs-src/lpmm_pipelines_guide.md b/docs-src/lpmm_pipelines_guide.md new file mode 100644 index 00000000..6539a2fc --- /dev/null +++ b/docs-src/lpmm_pipelines_guide.md @@ -0,0 +1,326 @@ +## LPMM 知识库流水线使用指南（命令行版） + +本文档介绍如何使用 `scripts/lpmm_manager.py` 及相关子脚本，完成 **导入 / 删除 / 自检 / 刷新 / 回归测试** 等常见流水线操作，并说明各参数在交互式与非交互（脚本化）场景下的用法。 + +所有命令均假设在项目根目录 `MaiBot/` 下执行： + +```bash +cd MaiBot +``` + +--- + +## 1. 管理脚本总览：`scripts/lpmm_manager.py` + +### 1.1 基本用法 + +```bash +python scripts/lpmm_manager.py [--interactive] [-a ACTION] [--non-interactive] [-- ...子脚本参数...] +``` + +- `--interactive` / `-i`：进入交互式菜单模式（推荐人工运维时使用）。 +- `--action` / `-a`：直接执行指定操作（非交互入口），可选值： + - `prepare_raw`：预处理 `data/lpmm_raw_data/*.txt`。 + - `info_extract`：信息抽取，生成 OpenIE JSON 批次。 + - `import_openie`：导入 OpenIE 批次到向量库与知识图。 + - `delete`：删除/回滚知识（封装 `delete_lpmm_items.py`）。 + - `batch_inspect`：检查指定 OpenIE 批次的存在情况。 + - `global_inspect`：全库状态统计。 + - `refresh`：刷新 LPMM 磁盘数据到内存。 + - `test`：检索效果回归测试。 + - `full_import`：一键执行「预处理原始语料 → 信息抽取 → 导入 → 刷新」。 +- `--non-interactive`： + - 启用 **非交互模式**：`lpmm_manager` 自身不会再调用 `input()` 询问确认； + - 同时自动向子脚本透传 `--non-interactive`（若子脚本支持），用于在 CI / 定时任务中实现无人值守。 +- `--` 之后的内容会原样传递给对应子脚本的 `main()`，用于设置更细粒度参数。 + +> 注意：`--interactive` 与 `--non-interactive` 互斥，不能同时使用。 + +--- + +## 2. 典型流水线一：全量导入（从原始 txt 到可用 LPMM） + +### 2.1 前置条件 + +- 将待导入的原始文本放入： + +```text +data/lpmm_raw_data/*.txt +``` + +- 文本按「空行分段」，每个段落为一条候选知识。 + +### 2.2 一键全流程（交互式） + +```bash +python scripts/lpmm_manager.py --interactive +``` + +菜单中依次： + +1. 选择 `9. full_import`（预处理 → 信息抽取 → 导入 → 刷新）。 +2. 按提示确认可能的费用与时间消耗。 +3. 等待脚本执行完成。 + +### 2.3 一键全流程（非交互 / CI 友好） + +```bash +python scripts/lpmm_manager.py -a full_import --non-interactive +``` + +执行顺序： + +1. `prepare_raw`：调用 `raw_data_preprocessor.load_raw_data()`，统计段落与去重哈希数。 +2. `info_extract`：调用 `info_extraction.main(--non-interactive)`，从 `data/lpmm_raw_data` 读取段落，生成 OpenIE JSON 并写入 `data/openie/`。 +3. `import_openie`：调用 `import_openie.main(--non-interactive)`，导入 OpenIE 批次到嵌入库与 KG。 +4. `refresh`：调用 `refresh_lpmm_knowledge.main()`，刷新 LPMM 知识库到内存。 + +在 `--non-interactive` 模式下： + +- 若 `data/lpmm_raw_data` 中没有 `.txt` 文件，或 `data/openie` 中没有 `.json` 文件，将直接报错退出，并在日志中说明缺少的目录/文件。 +- 若 OpenIE 批次中存在非法文段，导入脚本会 **直接报错退出**，不会卡在交互确认上。 + +--- + +## 3. 典型流水线二：分步导入 + +若需要逐步调试或只执行部分步骤，可以分开调用： + +### 3.1 预处理原始语料：`prepare_raw` + +```bash +python scripts/lpmm_manager.py -a prepare_raw +``` + +行为： +- 使用 `raw_data_preprocessor.load_raw_data()` 读取 `data/lpmm_raw_data/*.txt`； +- 输出段落总数与去重后的哈希数，供人工检查原始数据质量。 + +### 3.2 信息抽取：`info_extract` + +#### 交互式（带费用提示） + +```bash +python scripts/lpmm_manager.py -a info_extract +``` + +脚本会： +- 打印预计费用/时间提示； +- 询问 `确认继续执行？(y/n)`； +- 然后开始从 `data/lpmm_raw_data` 中读取段落，调用 LLM 提取实体与三元组，并生成 OpenIE JSON。 + +#### 非交互式（无人工确认） + +```bash +python scripts/lpmm_manager.py -a info_extract --non-interactive +``` + +行为差异： +- 跳过`确认继续执行`的交互提示，直接开始抽取； +- 若 `data/lpmm_raw_data` 下没有 `.txt` 文件，会打印告警并以错误方式退出。 + +### 3.3 导入 OpenIE 批次：`import_openie` + +#### 交互式 + +```bash +python scripts/lpmm_manager.py -a import_openie +``` + +脚本会： +- 提示导入开销与资源占用情况； +- 询问是否继续； +- 调用 `OpenIE.load()` 加载批次，再将其导入嵌入库与 KG。 + +#### 非交互式 + +```bash +python scripts/lpmm_manager.py -a import_openie --non-interactive +``` + +- 跳过导入开销确认； +- 若数据存在非法文段： + - 在交互模式下会询问是否删除这些非法文段并继续； + - 在非交互模式下，会直接 `logger.error` 并 `sys.exit(1)`，防止导入不完整数据。 + +> 提示：当前 `OpenIE.load()` 仍可能在内部要求你选择具体批次文件，若需完全无交互的导入，可后续扩展为显式指定文件路径。 + +### 3.4 刷新 LPMM 知识库：`refresh` + +```bash +python scripts/lpmm_manager.py -a refresh +# 或 +python scripts/lpmm_manager.py -a refresh --non-interactive +``` + +两者行为相同： +- 调用 `refresh_lpmm_knowledge.main()`，内部执行 `lpmm_start_up()`； +- 日志中输出当前向量与 KG 规模，验证导入是否成功。 + +--- + +## 4. 典型流水线三：删除 / 回滚 + +删除操作通过 `lpmm_manager.py -a delete` 封装 `scripts/delete_lpmm_items.py`。 + +### 4.1 交互式删除（推荐人工操作） + +```bash +python scripts/lpmm_manager.py --interactive +``` + +菜单中选择： + +1. `4. delete - 删除/回滚知识` +2. 再选择删除方式： + - 按哈希文件（`--hash-file`） + - 按 OpenIE 批次（`--openie-file`） + - 按原始语料 + 段落索引（`--raw-file + --raw-index`） + - 按关键字搜索现有段落（`--search-text`） +3. 管理脚本会根据你的选择自动拼好常用参数（是否删除实体/关系、是否删除孤立实体、是否 dry-run、是否自动确认等），最后调用 `delete_lpmm_items.py` 执行。 + +### 4.2 非交互删除（CI / 脚本场景） + +#### 示例：按哈希文件删除（带完整保护参数） + +```bash +python scripts/lpmm_manager.py -a delete --non-interactive -- \ + --hash-file data/lpmm_delete_hashes.txt \ + --delete-entities \ + --delete-relations \ + --remove-orphan-entities \ + --max-delete-nodes 2000 \ + --yes +``` + +- `--non-interactive`（manager）：禁止任何 `input()` 询问； +- 子脚本 `delete_lpmm_items.py` 中： + - `--hash-file`：指定待删段落哈希列表； + - `--delete-entities` / `--delete-relations` / `--remove-orphan-entities`：同步清理实体与关系； + - `--max-delete-nodes`：单次删除节点数上限，避免误删过大规模； + - `--yes`：跳过终极确认，适合已验证的自动流水线。 + +#### 按 OpenIE 批次删除（常用于批次回滚） + +```bash +python scripts/lpmm_manager.py -a delete --non-interactive -- \ + --openie-file data/openie/2025-01-01-12-00-openie.json \ + --delete-entities \ + --delete-relations \ + --remove-orphan-entities \ + --yes +``` + +### 4.3 非交互模式下的安全限制 + +在 `delete_lpmm_items.py` 中： + +- 若使用 `--search-text`，需要用户通过输入序号选择要删条目； + - 在 `--non-interactive` 模式下，这一步会直接报错退出，提示改用 `--hash-file / --openie-file / --raw-file` 等纯参数方式。 +- 若未指定 `--yes`： + - 非交互模式下会报错退出，提示「非交互模式且未指定 --yes，出于安全考虑删除操作已被拒绝」。 + +--- + +## 5. 典型流水线四：自检与状态检查 + +### 5.1 检查指定 OpenIE 批次状态：`batch_inspect` + +```bash +python scripts/lpmm_manager.py -a batch_inspect -- --openie-file data/openie/xx.json +``` + +输出该批次在当前库中的： +- 段落向量数量 / KG 段落节点数量； +- 实体向量数量 / KG 实体节点数量； +- 关系向量数量； +- 少量仍存在的样例内容。 + +常用于： +- 导入后确认是否完全成功； +- 删除后确认是否完全回滚。 + +### 5.2 查看整库状态：`global_inspect` + +```bash +python scripts/lpmm_manager.py -a global_inspect +``` + +输出： +- 段落 / 实体 / 关系向量条数； +- KG 节点/边总数，段落节点数、实体节点数； +- 实体计数表 `ent_appear_cnt` 的条目数； +- 少量剩余段落/实体样例，便于快速 sanity check。 + +--- + +## 6. 典型流水线五：检索效果回归测试 + +### 6.1 使用默认测试用例 + +```bash +python scripts/lpmm_manager.py -a test +``` + +- 调用 `test_lpmm_retrieval.py` 内置的 `DEFAULT_TEST_CASES`； +- 对每条用例输出： + - 原始结果； + - 状态（`PASS` / `WARN` / `NO_HIT` / `ERROR`）； + - 期望关键字与命中关键字列表。 + +### 6.2 自定义测试问题与期望关键字 + +```bash +python scripts/lpmm_manager.py -a test -- --query "LPMM 是什么？" \ + --expect-keyword 哈希列表 \ + --expect-keyword 删除脚本 +``` + +也可以直接调用子脚本： + +```bash +python scripts/test_lpmm_retrieval.py \ + --query "LPMM 是什么？" \ + --expect-keyword 哈希列表 \ + --expect-keyword 删除脚本 +``` + +--- + +## 7. 推荐组合示例 + +### 7.1 导入 + 刷新 + 简单回归 + +```bash +# 1. 执行全量导入（支持非交互） +python scripts/lpmm_manager.py -a full_import --non-interactive + +# 2. 使用内置用例做一次检索回归 +python scripts/lpmm_manager.py -a test +``` + +### 7.2 批次回滚 + 自检 + +```bash +TARGET_BATCH=data/openie/2025-01-01-12-00-openie.json + +# 1. 按批次删除（非交互） +python scripts/lpmm_manager.py -a delete --non-interactive -- \ + --openie-file "$TARGET_BATCH" \ + --delete-entities \ + --delete-relations \ + --remove-orphan-entities \ + --yes + +# 2. 检查该批次是否彻底删除 +python scripts/lpmm_manager.py -a batch_inspect -- --openie-file "$TARGET_BATCH" + +# 3. 查看全库状态 +python scripts/lpmm_manager.py -a global_inspect +``` + +--- + +如需扩展更多流水线（例如「导入特定批次后自动跑自定义测试用例」），可以在 `scripts/lpmm_manager.py` 中新增对应的 `ACTION_INFO` 条目和 `run_action` 分支，或直接在 CI / shell 脚本中串联上述命令。该管理脚本已支持参数化与非交互调用，适合作为二次封装的基础入口。 + + diff --git a/docs-src/lpmm_user_guide.md b/docs-src/lpmm_user_guide.md new file mode 100644 index 00000000..147ebcab --- /dev/null +++ b/docs-src/lpmm_user_guide.md @@ -0,0 +1,411 @@ +# LPMM 知识库脚本使用指南（零基础用户版） + +本指南面向不熟悉命令行和代码的 C 端用户，帮助你完成： + +- LPMM 知识库的初始部署（从本地 txt 到可检索知识库） +- 安全删除知识（按批次、按原文、按哈希、按关键字） +- 导入 / 删除后的自检与检索效果验证 + +> 说明：本文默认你已经完成 MaiBot 的基础安装，并能在项目根目录打开命令行终端。 +> 重要提醒：每次使用导入 / 删除相关脚本（如 `import_openie.py`、`delete_lpmm_items.py`）修改 LPMM 知识库后，聊天机器人 / WebUI 端要想看到最新知识，需要重启主程序，或在主程序内部显式调用一次 `lpmm_start_up()` 重新初始化 LPMM + +--- +。 + + +## 一、需要用到的脚本一览 + +在项目根目录（`MaiBot-dev`）下，这些脚本是 LPMM 相关的“工具箱”： + +- 导入相关： + - `scripts/raw_data_preprocessor.py` + 从 `data/lpmm_raw_data` 目录读取 `.txt` 文件，按空行拆分为一个个段落，并做去重。 + - `scripts/info_extraction.py` + 调用大模型，从每个段落里抽取实体和三元组，生成中间的 OpenIE JSON 文件。 + - `scripts/import_openie.py` + 把 `data/openie` 目录中的 OpenIE JSON 文件导入到 LPMM 知识库（向量库 + 知识图）。 +- 删除相关： + - `scripts/delete_lpmm_items.py` + LPMM 知识库删除入口，支持按批次、按原始文本段落、按哈希列表、按关键字模糊搜索删除。 +- 自检相关： + - `scripts/inspect_lpmm_global.py` + 查看整个知识库的当前状态：段落/实体/关系条数、知识图节点/边数量、示例内容等。 + - `scripts/inspect_lpmm_batch.py` + 针对某个 OpenIE JSON 批次，检查它在向量库和知识图中的“残留情况”（导入与删除前后对比）。 + - `scripts/test_lpmm_retrieval.py` + 使用几条预设问题测试 LPMM 检索能力，帮助你判断知识库是否正常工作。 + - `scripts/refresh_lpmm_knowledge.py` + 手动重新加载 `data/embedding` 和 `data/rag` 到内存，用来确认当前磁盘上的 LPMM 知识库能正常初始化。 + +> 注意：所有命令示例都假设你已经在虚拟环境中，命令行前缀类似 `(.venv)`，并且当前目录是项目根目录。 + +--- + +## 二、LPMM 知识库的初始部署 + +### 2.1 准备原始 txt 文本 + +1. 把要导入的知识文档放到： + + ```text + data/lpmm_raw_data + ``` + +2. 文件要求： + + - 必须是 `.txt` 文件，建议使用 UTF-8 编码； + - 用**空行**分隔段落：一段话后空一行，即视为一条独立知识。 + +示例文件： + +- `data/lpmm_raw_data/lpmm_large_sample.txt`：仓库内已经提供了一份大样本测试文本，可以直接用来练习。 + +### 2.2 第一步：预处理原始文本（拆段 + 去重） + +在项目根目录执行： + +```bash +.\.venv\Scripts\python.exe scripts/raw_data_preprocessor.py +``` + +成功时通常会看到日志类似： + +- 正在处理文件: `lpmm_large_sample.txt` +- 共读取到 XX 条数据 + +这一步不会调用大模型，仅做拆段和去重。 + +### 2.3 第二步：进行信息抽取（生成 OpenIE JSON） + +执行： + +```bash +.\.venv\Scripts\python.exe scripts/info_extraction.py +``` + +你会看到一个“重要操作确认”提示，说明： + +- 信息抽取会调用大模型，消耗 API 费用和时间； +- 如果确认无误，输入 `y` 回车继续。 + +提取过程中可能出现： + +- 类似“模型 ... 网络错误(可重试)”这样的日志； + 这表示脚本在遇到网络问题时自动重试，一般无需手动干预。 + +运行结束后，会有类似提示： + +```text +信息提取结果已保存到: data/openie/11-27-10-06-openie.json +``` + +- 请记住这个文件名，比如：`11-27-10-06-openie.json` + 接下来我们会用 `` 来代指这类文件。 + +### 2.4 第三步：导入 OpenIE 数据到 LPMM 知识库 + +执行： + +```bash +.\.venv\Scripts\python.exe scripts/import_openie.py +``` + +这个脚本会： + +- 从 `data/openie` 目录读取所有 `*.json` 文件，并合并导入； +- 将新段落的嵌入向量写入 `data/embedding`； +- 将三元组构建为知识图写入 `data/rag`。 + +> 提示：如果你希望“只导入某几批数据”，可以暂时把不需要的 JSON 文件移出 `data/openie`，导入结束后再移回。 + +### 2.5 第四步：全局自检（确认导入成功） + +执行： + +```bash +.\.venv\Scripts\python.exe scripts/inspect_lpmm_global.py +``` + +你会看到类似输出： + +- 段落向量条数: `52` +- 实体向量条数: `260` +- 关系向量条数: `299` +- KG 节点总数 / 边总数 / 段落节点数 / 实体节点数 +- 若干条示例段落与实体内容预览 + +只要这些数字大于 0，就表示 LPMM 知识库已经有可用的数据了。 + +### 2.6 第五步：用脚本测试 LPMM 检索效果（可选但推荐） + +执行： + +```bash +.\.venv\Scripts\python.exe scripts/test_lpmm_retrieval.py +``` + +脚本会： + +- 自动初始化 LPMM（加载向量库与知识图）； +- 用几条预设问题查询 LPMM； +- 打印原始检索结果和关键词命中情况。 + +你可以通过观察“RAW RESULT”里的内容，粗略判断： + +- 能否命中与问题高度相关的知识； +- 删除或导入新知识后，回答内容是否发生变化。 + +--- + +## 三、安全删除知识的几种方式 + +> 强烈建议：删除前先备份以下目录，以便“回档”： +> +> - `data/embedding`（向量库） +> - `data/rag`（知识图） + +所有删除操作使用同一个脚本： + +```bash +.\.venv\Scripts\python.exe scripts/delete_lpmm_items.py [参数...] +``` + +脚本特点： + +- 删除前会打印“待删除段落数量 / 实体数量 / 关系数量 / 预计删除节点数”等摘要； +- 需要你输入大写 `YES` 确认才会真正执行； +- 支持多种删除策略，可灵活组合。 + +### 3.1 按批次删除（推荐：整批回滚） + +适用场景：某次导入的整批知识有问题，希望整体回滚。 + +1. 删除前，先检查该批次状态： + + ```bash + .\.venv\Scripts\python.exe scripts/inspect_lpmm_batch.py ^ + --openie-file data/openie/.json + ``` + + 你会看到该批次： + + - 段落：总计多少条、向量库剩余多少、KG 中剩余多少； + - 实体、关系的类似统计； + - 少量示例段落/实体内容预览。 + +2. 确认无误后，按批次删除： + + ```bash + .\.venv\Scripts\python.exe scripts/delete_lpmm_items.py ^ + --openie-file data/openie/.json ^ + --delete-entities --delete-relations --remove-orphan-entities + ``` + + 参数含义： + + - `--delete-entities`：删除该批次涉及的实体向量； + - `--delete-relations`：删除该批次涉及的关系向量； + - `--remove-orphan-entities`：顺带清理删除后不再参与任何边的“孤立实体”节点。 + +3. 删除后再检查： + + ```bash + .\.venv\Scripts\python.exe scripts/inspect_lpmm_batch.py ^ + --openie-file data/openie/.json + + .\.venv\Scripts\python.exe scripts/inspect_lpmm_global.py + ``` + + 若批次检查显示“向量库剩余 0 / KG 中剩余 0”，则说明该批次已被彻底删除。 + +### 3.2 按原始文本段落删除（精确定位某一段） + +适用场景：某个原始 txt 的特定段落写错了，只想删这段对应的知识。 + +命令示例： + +```bash +.\.venv\Scripts\python.exe scripts/delete_lpmm_items.py ^ + --raw-file data/lpmm_raw_data/lpmm_large_sample.txt ^ + --raw-index 2 +``` + +说明： + +- `--raw-index` 从 1 开始计数，可用逗号多选，例如：`1,3,5`； +- 脚本会展示该段落的内容预览和哈希值，再请求你确认。 + +### 3.3 按哈希列表删除（进阶用法） + +适用场景：你有一份“需要删除的段落哈希列表”（比如从其他系统导出）。 + +示例哈希列表文件： + +- `data/openie/lpmm_delete_test_hashes.txt` + +命令： + +```bash +.\.venv\Scripts\python.exe scripts/delete_lpmm_items.py ^ + --hash-file data/openie/lpmm_delete_test_hashes.txt +``` + +说明： + +- 文件中每行一条，可以是 `paragraph-xxxx` 或纯哈希，脚本会自动识别； +- 适合“精确控制删除哪些段落”，但准备哈希列表需要一定技术基础。 + +### 3.4 按关键字模糊搜索删除（对非技术用户最友好） + +适用场景：只知道某段话里包含某个关键词，不知道它在哪个 txt 或批次里。 + +示例 1：删除与“近义词扩展”相关的段落 + +```bash +.\.venv\Scripts\python.exe scripts/delete_lpmm_items.py --search-text "近义词扩展" --search-limit 5 +``` + +示例 2：删除与“LPMM”强相关的一些段落 + +```bash +.\.venv\Scripts\python.exe scripts/delete_lpmm_items.py --search-text "LPMM" --search-limit 20 + +``` + +执行过程： + +1. 脚本在当前段落库中查找包含该关键字的段落； +2. 列出前 N 条候选（`--search-limit` 决定数量）； +3. 提示你输入要删除的序号列表，例如：`1,2,5`； +4. 再次提示你输入 `YES` 确认，才会真正执行删除。 + +> 建议： +> +> - 第一次使用时可以先加 `--dry-run` 看看效果： +> ```bash +> .\.venv\Scripts\python.exe scripts/delete_lpmm_items.py ^ +> --search-text "LPMM" ^ +> --search-limit 20 ^ +> --dry-run +> ``` +> - 确认候选列表确实是你要删的内容后，再去掉 `--dry-run` 正式执行。 + +--- + +## 四、自检：如何确认导入 / 删除是否“生效” + +### 4.1 全局状态检查 + +每次导入或删除之后，建议跑一次： + +```bash +.\.venv\Scripts\python.exe scripts/inspect_lpmm_global.py +``` + +你可以在这里看到： + +- 段落向量条数、实体向量条数、关系向量条数； +- 知识图的节点总数、边总数、段落节点和实体节点数量； +- 若干条“剩余段落示例”和“剩余实体示例”。 + +观察方式： + +- 导入后：数字应该明显上升（说明新增数据生效）； +- 删除后：数字应该明显下降（说明删除操作生效）。 + +### 4.2 某个批次的局部状态 + +如果你想确认“某一个 OpenIE 文件对应的那一批知识”是否存在，可以使用： + +```bash +.\.venv\Scripts\python.exe scripts/inspect_lpmm_batch.py --openie-file data/openie/.json +``` + +输出中会包含： + +- 该批次的段落 / 实体 / 关系的总数； +- 在向量库中还剩多少条，在 KG 中还剩多少条； +- 若干条仍存在的段落/实体示例。 + +典型用法： + +- 导入后立刻检查一次：确认这一批已经“写入”； +- 删除后再检查一次：确认这一批是否已经“清空”。 + +### 4.3 检索效果回归测试 + +每次做完导入或删除，你都可以用这条命令快速验证检索效果： + +```bash +.\.venv\Scripts\python.exe scripts/test_lpmm_retrieval.py +``` + +它会： + +- 初始化 LPMM（加载当前向量库和知识图）； +- 用几条预设问题（包括与 LPMM 和配置相关的问题）进行检索； +- 打印检索结果以及命中关键词情况。 + +通过对比不同时间点的输出，你可以判断： + +- 某些知识是否已经被成功删除（不再出现在回答中）； + +- 新增的知识是否已经能被检索到。 + +### 4.4 进阶：一键刷新（可选） + +- 想简单确认“现在这份 data/embedding + data/rag 是否健康”？执行： + + `.\.venv\Scripts\python.exe scripts/refresh_lpmm_knowledge.py ` + + 它会尝试初始化 LPMM，并打印当前段落/实体/关系条数和图大小。 + + + + + +--- + +## 五、常见提示与注意事项 + +1. **看到“网络错误(可重试)”需要担心吗？** + + - 不需要。 + - 这些日志说明脚本在自动处理网络抖动，多数情况下会在重试后成功返回结果。 + - 只要脚本最后没有报“重试耗尽并退出”，一般导入/提取结果是有效的。 + +2. **删除操作会不会“一删全没”？** + + - 不会直接“一删全没”： + - 每次删除会打印摘要信息； + - 必须输入 `YES` 才会真正执行； + - 大批次时还有 `--max-delete-nodes` 保护，超过阈值会警告。 + - 但仍然建议： + - 在大规模删除前备份 `data/embedding` 和 `data/rag`； + - 先通过 `--dry-run` 看看待删列表。 + +3. **可以多次导入吗？需要先清空吗？** + + - 可以多次导入，系统会根据段落内容的哈希做去重； + - 不需要每次都清空，只要你希望老数据仍然保留即可； + - 如果你确实想“重来一遍”，可以： + - 先备份，然后删除 `data/embedding` 和 `data/rag`； + - 再重新跑导入流程。 + +4. **LPMM 开关在哪里？** + + - 配置文件：`config/bot_config.toml`； + - 小节：`[lpmm_knowledge]`； + - 其中有 `enable = true/false` 开关： + - 为 `true`：LPMM 知识库启用，问答时会使用； + - 为 `false`：LPMM 关闭，即使知识库有数据，也不会参与回答。 + - 修改后需要重启主程序，让设置生效。 + +--- + +如果你是普通用户，只需要记住一句话： + +> “导入三步走：预处理 → 信息抽取 → 导入 OpenIE； +> 删除三步走：先检查 → 再删除 → 然后再检查。” + +照着本指南中的命令一步一步执行，就可以安全地管理你的 LPMM 知识库。*** diff --git a/dummy b/dummy new file mode 100644 index 00000000..5cae3661 --- /dev/null +++ b/dummy @@ -0,0 +1,10 @@ +{ + "cells": [], + "metadata": { + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} \ No newline at end of file diff --git a/helm-chart/.gitignore b/helm-chart/.gitignore index b5ec6e00..8c2aec04 100644 --- a/helm-chart/.gitignore +++ b/helm-chart/.gitignore @@ -1 +1,2 @@ !napcat +!.env \ No newline at end of file diff --git a/helm-chart/.gitlab-ci.yml b/helm-chart/.gitlab-ci.yml index ce6f25e5..d00ae558 100644 --- a/helm-chart/.gitlab-ci.yml +++ b/helm-chart/.gitlab-ci.yml @@ -8,35 +8,18 @@ workflow: - if: '$CI_COMMIT_BRANCH == "helm-chart"' - when: never -# 构建并推送adapter-cm-generator镜像 -build-adapter-cm-generator: +# 构建并推送processor镜像 +build-preprocessor: stage: build-image image: reg.mikumikumi.xyz/base/kaniko-builder:latest variables: BUILD_NO_CACHE: true rules: - changes: - - helm-chart/adapter-cm-generator/** + - helm-chart/preprocessor/** script: - - export BUILD_CONTEXT=helm-chart/adapter-cm-generator - - export TMP_DST=reg.mikumikumi.xyz/maibot/adapter-cm-generator - - export CHART_VERSION=$(cat helm-chart/Chart.yaml | grep '^version:' | cut -d' ' -f2) - - export BUILD_DESTINATION="${TMP_DST}:${CHART_VERSION}" - - export BUILD_ARGS="--destination ${TMP_DST}:latest" - - build - -# 构建并推送core-webui-cm-sync镜像 -build-core-webui-cm-sync: - stage: build-image - image: reg.mikumikumi.xyz/base/kaniko-builder:latest - variables: - BUILD_NO_CACHE: true - rules: - - changes: - - helm-chart/core-webui-cm-sync/** - script: - - export BUILD_CONTEXT=helm-chart/core-webui-cm-sync - - export TMP_DST=reg.mikumikumi.xyz/maibot/core-webui-cm-sync + - export BUILD_CONTEXT=helm-chart/preprocessor + - export TMP_DST=reg.mikumikumi.xyz/maibot/preprocessor - export CHART_VERSION=$(cat helm-chart/Chart.yaml | grep '^version:' | cut -d' ' -f2) - export BUILD_DESTINATION="${TMP_DST}:${CHART_VERSION}" - export BUILD_ARGS="--destination ${TMP_DST}:latest" diff --git a/helm-chart/.helmignore b/helm-chart/.helmignore index d4fe42ef..84ca3f29 100644 --- a/helm-chart/.helmignore +++ b/helm-chart/.helmignore @@ -1,3 +1,2 @@ -adapter-cm-generator -core-webui-cm-sync +preprocessor .gitlab-ci.yml \ No newline at end of file diff --git a/helm-chart/Chart.yaml b/helm-chart/Chart.yaml index ea75ef79..e77ebde3 100644 --- a/helm-chart/Chart.yaml +++ b/helm-chart/Chart.yaml @@ -2,5 +2,5 @@ apiVersion: v2 name: maibot description: "Maimai Bot, a cyber friend dedicated to group chats" type: application -version: 0.11.5-beta -appVersion: 0.11.5-beta +version: 0.12.0 +appVersion: 0.12.0 diff --git a/helm-chart/README.md b/helm-chart/README.md index edbb417c..f3929696 100644 --- a/helm-chart/README.md +++ b/helm-chart/README.md @@ -10,6 +10,8 @@ | Helm Chart版本 | 对应的MaiBot版本 | Commit SHA | |----------------|--------------|------------------------------------------| +| 0.12.0 | 0.12.0 | baa6e90be7b20050fe25dfc74c0c70653601d00e | +| 0.11.6-beta | 0.11.6-beta | 0bfff0457e6db3f7102fb7f77c58d972634fc93c | | 0.11.5-beta | 0.11.5-beta | ad2df627001f18996802f23c405b263e78af0d0f | | 0.11.3-beta | 0.11.3-beta | cd6dc18f546f81e08803d3b8dba48e504dad9295 | | 0.11.2-beta | 0.11.2-beta | d3c8cea00dbb97f545350f2c3d5bcaf252443df2 | @@ -34,35 +36,39 @@ helm install maimai \ 1. `EULA` & `PRIVACY`: 用户必须同意这里的协议才能成功部署麦麦。 -2. `adapter`: 麦麦的Adapter的部署配置。 +2. `pre_processor`: 部署之前的预处理Job的配置。 -3. `core`: 麦麦本体的部署配置。 +3. `adapter`: 麦麦的Adapter的部署配置。 -4. `statistics_dashboard`: 麦麦的运行统计看板部署配置。 +4. `core`: 麦麦本体的部署配置。 + +5. `statistics_dashboard`: 麦麦的运行统计看板部署配置。 麦麦每隔一段时间会自动输出html格式的运行统计报告，此统计报告可以部署为看板。 出于隐私考虑，默认禁用。 -5. `napcat`: Napcat的部署配置。 +6. `napcat`: Napcat的部署配置。 考虑到复用外部Napcat实例的情况，Napcat部署已被解耦。用户可选是否要部署Napcat。 默认会捆绑部署Napcat。 -6. `sqlite_web`: sqlite-web的部署配置。 +7. `sqlite_web`: sqlite-web的部署配置。 通过sqlite-web可以在网页上操作麦麦的数据库，方便调试。不部署对麦麦的运行无影响。 此服务如果暴露在公网会十分危险，默认不会部署。 -7. `config`: 这里填写麦麦各部分组件的运行配置文件。 +8. `config`: 这里填写麦麦各部分组件的运行配置。 - 这里填写的配置文件需要严格遵守yaml文件的缩进格式。 + 这里填写的配置仅会在初次部署时或用户指定时覆盖实际配置文件，且需要严格遵守yaml文件的缩进格式。 + + - `override_*_config`: 指定本次部署/升级是否用以下配置覆盖实际配置文件。默认不覆盖。 - `adapter_config`: 对应adapter的`config.toml`。 - 此配置文件中对于`host`和`port`的配置会被上面`adapter.service`中的配置覆盖，因此不需要改动。 + 此配置文件中对于`napcat_server`和`maibot_server`的`host`和`port`字段的配置会被上面`adapter.service`中的配置覆盖，因此不需要改动。 - `core_model_config`: 对应core的`model_config.toml`。 @@ -72,60 +78,41 @@ helm install maimai \ 使用此Helm Chart的一些注意事项。 -### 修改麦麦配置 +### 麦麦的配置 -麦麦的配置文件会通过ConfigMap资源注入各个组件内。 +要修改麦麦的配置，最好的方法是通过WebUI来操作。此处的配置只会在初次部署时或者指定覆盖时注入到MaiBot中。 -对于通过Helm Chart部署的麦麦，如果需要修改配置，不应该直接修改这些ConfigMap，否则下次Helm更新可能会覆盖掉所有配置。 +`0.11.6-beta`之前的版本将配置存储于k8s的ConfigMap资源中。随着版本迭代，MaiBot对配置文件的操作复杂性增加，k8s的适配复杂度也同步增加，且WebUI可以直接修改配置文件，因此自`0.11.6-beta`版本开始，各组件的配置不再存储于k8s的ConfigMap中，而是直接存储于存储卷的实际文件中。 -最佳实践是重新配置Helm Chart的values，然后通过`helm upgrade`更新实例。 +从旧版本升级的用户，旧的ConfigMap的配置会自动迁移到新的存储卷的配置文件中。 -### 动态生成的ConfigMap +### 部署时自动重置的配置 -adapter的ConfigMap是每次部署/更新Helm安装实例时动态生成的。 +adapter的配置中的`napcat_server`和`maibot_server`的`host`和`port`字段，会在每次部署/更新Helm安装实例时被自动重置。 +core的配置中的`webui`和`maim_message`的部分字段也会在每次部署/更新Helm安装实例时被自动重置。 -动态生成的原因： +自动重置的原因： -- core服务的DNS名称是动态的，无法在adapter服务的配置文件中提前确定。 -- 一些与k8s现有资源冲突的配置需要被重置。 +- core的Service的DNS名称是动态的（由安装实例名拼接），无法在adapter的配置文件中提前确定。 +- 为了使adapter监听所有地址以及保持Helm Chart中配置的端口号，需要在adapter的配置文件中覆盖这些配置。 +- core的WebUI启停需要由helm chart控制，以便正常创建Service和Ingress资源。 +- core的maim_message的api server现在可以作为k8s服务暴露出来。监听的IP和端口需要由helm chart控制，以便Service正确映射。 -因此，首次部署时，ConfigMap的生成会需要一些时间，部分Pod会无法启动，等待几分钟即可。 +首次部署时，预处理任务会负责重置这些配置。这会需要一些时间，因此部署进程可能比较慢，且部分Pod可能会无法启动，等待一分钟左右即可。 -### 运行统计看板与core的挂载冲突 +### 跨节点PVC挂载问题 -如果启用了运行统计看板，那么statistics_dashboard会与core共同挂载statistics_dashboard存储卷，用于同步html文件。 +MaiBot的一些组件会挂载同一PVC，这主要是为了同步数据或修改配置。 -如果k8s集群有多个节点，且statistics_dashboard与core未调度到同一节点，那么就需要statistics_dashboard的PVC访问模式具备`ReadWriteMany`访问模式。 +如果k8s集群有多个节点，且共享相同PVC的Pod未调度到同一节点，那么就需要此PVC访问模式具备`ReadWriteMany`访问模式。 -不是所有存储卷的底层存储都支持`ReadWriteMany`访问模式。 +不是所有存储控制器都支持`ReadWriteMany`访问模式。 -如果你的存储底层无法支持`ReadWriteMany`访问模式，你可以通过`nodeSelector`配置将statistics_dashboard与core调度到同一节点来避免问题。 +如果你的存储控制器无法支持`ReadWriteMany`访问模式，你可以通过`nodeSelector`配置将彼此之间共享相同PVC的Pod调度到同一节点来避免问题。 -*如果启用了`sqlite-web`，那么上述问题也同样适用于`sqlite-web`与`core`，需要注意。* +会共享PVC的组件列表： -### 麦麦的默认插件 - -麦麦的`core`容器提供了一些默认插件，以提升使用体验。但是插件目录存储在存储卷中，容器启动时挂载的存储卷会完全覆盖掉容器的默认插件目录，导致默认插件无法加载，也难以被用户感知。 - -为了解决这一问题，此Helm Chart中为`core`容器引入了初始化容器。此初始化容器用于为用户自动安装默认插件到存储卷中。可以选择启用（默认启用）。 - -*初始化容器使用与`core`主容器相同的镜像，且用后即销毁，因此不会消耗额外的带宽和存储成本。* - -#### 触发插件安装的条件 - -- 首次部署时（此时没有任何插件处于安装状态） -- 默认插件更新（即默认插件内容发生变化） - -#### 安装状态识别能力 - -初始化容器会记录安装过的默认插件，不会重复安装。为了实现这一点，初始化容器会将安装状态写入`/MaiMBot/data/plugins/.installed-setup-plugins`文件中。 - -基于上述状态识别能力，如果用户不需要某个插件，可以将其删除。由于此插件已自动安装过（记录在状态文件中），即使插件本体不存在也不会再次安装（除非插件更新）。 - -#### 插件更新 - -一旦在镜像中检测到新版本插件（即插件内容不同），初始化容器即会用新插件覆盖旧插件。 - -考虑到旧插件中可能存在用户自定义配置，因此旧插件在被覆盖前会备份到`/MaiMBot/data/plugins-backup`目录中，并以时间归档。 - -因此在升级麦麦后，请注意观察初始容器的日志并重新配置插件。 +- `core`和`adapter`：共享`adapter-config`，用于为`core`的WebUI提供修改adapter的配置文件的能力。 +- `core`和`statistics-dashboard`：共享`statistics-dashboard`，用于同步统计数据的html文件。 +- `core`和`sqlite-web`：共享`maibot-core`，用于为`sqlite-web`提供操作MaiBot数据库的能力。 +- 部署时的预处理任务`preprocessor`和`adapter`、`core`：共享`adapter-config`和`core-config`，用于初始化`core`和`adapter`的配置文件。 diff --git a/helm-chart/adapter-cm-generator/adapter-cm-generator.py b/helm-chart/adapter-cm-generator/adapter-cm-generator.py deleted file mode 100644 index 95d7b65b..00000000 --- a/helm-chart/adapter-cm-generator/adapter-cm-generator.py +++ /dev/null @@ -1,73 +0,0 @@ -#!/bin/python3 -# 这个脚本的作用是在部署helm chart时动态生成adapter的配置文件，保存在configmap中 -# 需要动态生成的原因是core服务的DNS名称是动态的，无法在adapter服务的配置文件中提前确定 -# 一些与k8s现有资源冲突的配置也会在这里重置 - -import os -import toml -import base64 -from kubernetes import client, config -from datetime import datetime, timezone - -config.load_incluster_config() -core_api = client.CoreV1Api() -apps_api = client.AppsV1Api() - -# 读取部署的关键信息 -namespace = os.getenv("NAMESPACE") -release_name = os.getenv("RELEASE_NAME") -data_b64 = os.getenv("DATA_B64") - -# 解析并覆盖关键配置 -# 这里被覆盖的配置应当在helm chart中针对对应的k8s资源来灵活修改 -data = toml.loads(base64.b64decode(data_b64).decode("utf-8")) -data.setdefault('napcat_server', {}) -data['napcat_server']['host'] = '0.0.0.0' -data['napcat_server']['port'] = 8095 -data.setdefault('maibot_server', {}) -data['maibot_server']['host'] = f'{release_name}-maibot-core' # 根据release名称动态拼接core服务的DNS名称 -data['maibot_server']['port'] = 8000 - -# 创建/修改configmap -cm_name = f'{release_name}-maibot-adapter-config' -cm = client.V1ConfigMap( - metadata=client.V1ObjectMeta(name=cm_name), - data={'config.toml': toml.dumps(data)} -) -try: - core_api.create_namespaced_config_map(namespace, cm) - print(f"ConfigMap `{cm_name}` created successfully") -except client.exceptions.ApiException as e: - if e.status == 409: # 已存在，更新 - core_api.replace_namespaced_config_map(cm_name, namespace, cm) - print(f"ConfigMap `{cm_name}` replaced successfully") - else: - raise - -# 重启adapter和core的statefulset -now = datetime.now(timezone.utc).isoformat() -body = { - "spec": { - "template": { - "metadata": { - "annotations": { - "kubectl.kubernetes.io/restartedAt": now - } - } - } - } -} -apps_api.patch_namespaced_stateful_set( - name=f'{release_name}-maibot-adapter', - namespace=namespace, - body=body, -) -print(f"StatefulSet `{release_name}-maibot-adapter` restarted successfully") -apps_api.patch_namespaced_stateful_set( - name=f'{release_name}-maibot-core', - namespace=namespace, - body=body, -) -print(f"StatefulSet `{release_name}-maibot-core` restarted successfully") - -print('Job succeed.') diff --git a/helm-chart/core-webui-cm-sync/Dockerfile b/helm-chart/core-webui-cm-sync/Dockerfile deleted file mode 100644 index 55a8c25b..00000000 --- a/helm-chart/core-webui-cm-sync/Dockerfile +++ /dev/null @@ -1,10 +0,0 @@ -# 此镜像用于辅助麦麦的WebUI更新配置文件，随core容器持续运行 -FROM python:3.13-slim - -WORKDIR /MaiMBot - -COPY . /MaiMBot - -RUN pip3 install --no-cache-dir -r requirements.txt - -ENTRYPOINT ["python3", "core-webui-cm-sync.py"] diff --git a/helm-chart/core-webui-cm-sync/core-webui-cm-sync.py b/helm-chart/core-webui-cm-sync/core-webui-cm-sync.py deleted file mode 100644 index e179d6f6..00000000 --- a/helm-chart/core-webui-cm-sync/core-webui-cm-sync.py +++ /dev/null @@ -1,92 +0,0 @@ -#!/bin/python3 -# 这个程序的作用是辅助麦麦的WebUI更新配置文件，随core容器持续运行。 -# 麦麦的配置文件存储于ConfigMap中，挂载进core容器后属于只读文件，无法直接修改。 -# 此程序将core容器内的配置文件替换为可读写的中间层临时文件。启动时将实际配置文件写入，并在后台持续检测文件变化，实时同步到k8s apiServer，反向修改ConfigMap。 -# 工作目录：/MaiMBot/webui-cm-sync - -import os -import time -from datetime import datetime -from kubernetes import client, config -from watchdog.observers import Observer -from watchdog.events import FileSystemEventHandler - -work_dir = '/MaiMBot/webui-cm-sync' -os.chdir(work_dir) - -config.load_incluster_config() -core_api = client.CoreV1Api() -with open("/var/run/secrets/kubernetes.io/serviceaccount/namespace", "r") as f: - namespace = f.read().strip() -release_name = os.getenv("RELEASE_NAME") -model_configmap_name = f'{release_name}-maibot-core-model-config' -bot_configmap_name = f'{release_name}-maibot-core-bot-config' - -# 过滤列表，只监控指定文件 -target_files = { - os.path.abspath("model_config.toml"): (model_configmap_name, "model_config.toml"), - os.path.abspath("bot_config.toml"): (bot_configmap_name, "bot_config.toml") -} - - -def get_configmap(configmap_name: str): - """获取core的ConfigMap内容""" - cm = core_api.read_namespaced_config_map(name=configmap_name, namespace=namespace) - return cm.data - - -def set_configmap(configmap_name: str, configmap_data: dict[str, str]): - """设置core的ConfigMap内容""" - core_api.patch_namespaced_config_map(configmap_name, namespace, {'data': configmap_data}) - - -class ConfigObserverHandler(FileSystemEventHandler): - """配置文件变化的事件处理器""" - def on_modified(self, event): - if os.path.abspath(event.src_path) in target_files: - print(f'[{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}] File `{event.src_path}` was modified. ' - f'Start to sync...') - with open(event.src_path, "r", encoding="utf-8") as _f: - current_data = _f.read() - _path = str(os.path.abspath(event.src_path)) - new_cm = { - target_files[_path][1]: current_data - } - try: - set_configmap(target_files[_path][0], new_cm) - print(f'\tSync done.') - except client.exceptions.ApiException as _e: - print(f'\tError while setting configmap:\n' - f'\t\tStatus Code: {_e.status}\n' - f'\t\tReason: {_e.reason}') - - -if __name__ == '__main__': - # 初始化配置文件 - print(f'[{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}] Initializing config files...') - try: - __initial_model_config = get_configmap(model_configmap_name)['model_config.toml'] - __initial_bot_config = get_configmap(bot_configmap_name)['bot_config.toml'] - except client.exceptions.ApiException as e: - print(f'\tError while getting configmap:\n' - f'\t\tStatus Code: {e.status}\n' - f'\t\tReason: {e.reason}') - exit(1) - with open('model_config.toml', 'w') as f: - f.write(__initial_model_config) - with open('bot_config.toml', 'w') as f: - f.write(__initial_bot_config) - with open('ready', 'w') as f: - f.write('true') - print(f'[{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}] Initializing done. Ready to sync.') - - # 持续检测变化并同步 - observer = Observer() - observer.schedule(ConfigObserverHandler(), work_dir, recursive=False) - observer.start() - try: - while True: - time.sleep(1) - except KeyboardInterrupt: - observer.stop() - observer.join() diff --git a/helm-chart/core-webui-cm-sync/requirements.txt b/helm-chart/core-webui-cm-sync/requirements.txt deleted file mode 100644 index 58c73d28..00000000 --- a/helm-chart/core-webui-cm-sync/requirements.txt +++ /dev/null @@ -1,3 +0,0 @@ -toml~=0.10.2 -kubernetes~=34.1.0 -watchdog~=6.0.0 diff --git a/helm-chart/files/.env b/helm-chart/files/.env new file mode 100644 index 00000000..c34eed76 --- /dev/null +++ b/helm-chart/files/.env @@ -0,0 +1,4 @@ +HOST=0.0.0.0 +PORT=8000 +WEBUI_HOST=0.0.0.0 +WEBUI_PORT=8001 diff --git a/helm-chart/files/k8s-init.sh b/helm-chart/files/k8s-init.sh index 3729a68f..3fd805f4 100644 --- a/helm-chart/files/k8s-init.sh +++ b/helm-chart/files/k8s-init.sh @@ -1,12 +1,8 @@ #!/bin/sh # 此脚本用于覆盖core容器的默认启动命令，进行一些初始化 -# 1 # 由于k8s与docker-compose的卷挂载方式有所不同，需要利用此脚本为一些文件和目录提前创建好软链接 # /MaiMBot/data是麦麦数据的实际挂载路径 # /MaiMBot/statistics是统计数据的实际挂载路径 -# 2 -# 此脚本等待辅助容器webui-cm-sync就绪后再启动麦麦 -# 通过检测/MaiMBot/webui-cm-sync/ready文件来判断 set -e echo "[K8s Init] Preparing volume..." @@ -34,22 +30,6 @@ fi echo "[K8s Init] Volume ready." -# 如果启用了WebUI，则等待辅助容器webui-cm-sync就绪，然后创建中间层配置文件软链接 -if [ "$MAIBOT_WEBUI_ENABLED" = "true" ] -then - echo "[K8s Init] WebUI enabled. Waiting for container 'webui-cm-sync' ready..." - while [ ! -f /MaiMBot/webui-cm-sync/ready ]; do - sleep 1 - done - echo "[K8s Init] Container 'webui-cm-sync' ready." - mkdir -p /MaiMBot/config - ln -s /MaiMBot/webui-cm-sync/model_config.toml /MaiMBot/config/model_config.toml - ln -s /MaiMBot/webui-cm-sync/bot_config.toml /MaiMBot/config/bot_config.toml - echo "[K8s Init] Config files middle layer for WebUI created." -else - echo "[K8s Init] WebUI is disabled." -fi - # 启动麦麦 echo "[K8s Init] Waking up MaiBot..." echo diff --git a/helm-chart/files/setup-plugins.py b/helm-chart/files/setup-plugins.py deleted file mode 100644 index 9fde6804..00000000 --- a/helm-chart/files/setup-plugins.py +++ /dev/null @@ -1,95 +0,0 @@ -#!/usr/local/bin/python3 -# 用户插件目录存储在存储卷中，会在启动时覆盖掉容器的默认插件目录。此脚本用于默认插件更新后或麦麦首次启动时为用户自动安装默认插件到存储卷中 -# 如果用户主动删除插件且插件无更新，则不会再次安装。插件状态保存在/MaiMBot/data/plugins/.installed-setup-plugins文件中 -# 此脚本应当挂载进初始化容器中，从/MaiMBot工作路径开始运行。初始化容器的镜像同core容器，初始化容器中应挂载core存储卷的数据到/MaiMBot/data -import os -import shutil -import hashlib -from datetime import datetime - -SRC_DIR = '/MaiMBot/plugins' -DST_DIR = '/MaiMBot/data/plugins' -STATUS_FILE = f'{DST_DIR}/.installed-setup-plugins' -BAK_DIR = '/MaiMBot/data/plugins-backup' -CURRENT_TIME = datetime.now().strftime('%Y%m%d%H%M%S') - -def hash_dir_file(path: str): - """计算目录/文件的SHA256，用于判断是否发生变化""" - def hash_file(_file_path: str): - _h = hashlib.sha256() - with open(_file_path, 'rb') as _f: - for _chunk in iter(lambda: _f.read(8192), b''): - _h.update(_chunk) - return _h.hexdigest() - - if os.path.isfile(path): - return hash_file(path) - - h = hashlib.sha256() - for root, dirs, files in os.walk(path): - for filename in sorted(files): - filepath = os.path.join(root, filename) - relpath = os.path.relpath(filepath, path) - file_hash = hash_file(filepath) - h.update(relpath.encode('utf-8')) - h.update(file_hash.encode('utf-8')) - return h.hexdigest() - -def copy_plugin(plugin: str): - """复制插件，如果插件已存在则备份旧的插件然后用新的插件覆盖""" - src = os.path.join(SRC_DIR, plugin) - if not os.path.exists(src): - raise FileNotFoundError(f"File not found: {src}") - - dst = os.path.join(DST_DIR, plugin) - if os.path.exists(dst): - print(f"\t\tWarning: Old version of plugin '{plugin}' already exists. " - f"Old plugin will be moved to '{BAK_DIR}/{CURRENT_TIME}/{plugin}'. " - f"Remember to re-edit config of this plugin.") - if not os.path.exists(os.path.join(BAK_DIR, CURRENT_TIME)): - os.makedirs(os.path.join(BAK_DIR, CURRENT_TIME)) - if os.path.isdir(dst): - shutil.copytree(dst, os.path.join(BAK_DIR, CURRENT_TIME, plugin)) - shutil.rmtree(dst) - else: - shutil.copy2(dst, os.path.join(BAK_DIR, CURRENT_TIME)) - os.remove(dst) - - if os.path.isdir(src): - shutil.copytree(src, dst) - else: - shutil.copy2(src, DST_DIR) - -setup_plugins = {plugin: hash_dir_file(plugin) for plugin in os.listdir(SRC_DIR)} -installed_plugins = {} -to_install_plugins = {} - -print(f"[SetupPlugins] Default plugin, which has been updated or never been installed, " - f"will be installed in this init container.") -if os.path.exists(STATUS_FILE) and os.path.isfile(STATUS_FILE): - print(f"[SetupPlugins] Reading status file: '{STATUS_FILE}'...") - with open(STATUS_FILE, 'r', encoding='utf-8') as f: - lines = f.readlines() - for line in lines: - if line == '': - continue - plugin = line.strip().split(':') - installed_plugins[plugin[0]] = plugin[1] - print(f"[SetupPlugins] Found {len(installed_plugins)} default plugins which used to be installed:") - for plugin in installed_plugins.keys(): - print(f'\t{plugin}') -else: - print(f"[SetupPlugins] No status file found. Status file '{STATUS_FILE}' will be created. " - f"All default plugins will be installed now.") - -print(f"[SetupPlugins] Checking plugins...") -for plugin, sha256 in setup_plugins.items(): - if (plugin not in installed_plugins) or (sha256 != installed_plugins[plugin]): - print(f"\tFound default plugin to install: '{plugin}'. Installing...") - copy_plugin(plugin) - installed_plugins[plugin] = sha256 - -with open(STATUS_FILE, 'w', encoding='utf-8') as f: - f.write('\n'.join(sorted([f'{plugin}:{sha256}' for plugin, sha256 in installed_plugins.items()]))) - -print(f"[SetupPlugins] Default plugin checking done. Status saved to '{STATUS_FILE}'.") diff --git a/helm-chart/adapter-cm-generator/Dockerfile b/helm-chart/preprocessor/Dockerfile similarity index 72% rename from helm-chart/adapter-cm-generator/Dockerfile rename to helm-chart/preprocessor/Dockerfile index 3149f0f5..58452dd5 100644 --- a/helm-chart/adapter-cm-generator/Dockerfile +++ b/helm-chart/preprocessor/Dockerfile @@ -3,8 +3,10 @@ FROM python:3.13-slim WORKDIR /app +ENV PYTHONUNBUFFERED=1 + COPY . /app RUN pip3 install --no-cache-dir -r requirements.txt -ENTRYPOINT ["python3", "adapter-cm-generator.py"] +ENTRYPOINT ["python3", "preprocessor.py"] diff --git a/helm-chart/preprocessor/preprocessor.py b/helm-chart/preprocessor/preprocessor.py new file mode 100644 index 00000000..e8fe5b11 --- /dev/null +++ b/helm-chart/preprocessor/preprocessor.py @@ -0,0 +1,266 @@ +#!/bin/python3 +# 此脚本会被helm chart的post-install hook触发，在正式部署后通过k8s的job自动运行一次。 +# 这个脚本的作用是在部署helm chart时迁移旧版ConfigMap到配置文件，调整adapter的配置文件中的服务监听和服务连接字段，调整core的配置文件中的maim_message_api_server和WebUI配置。 +# +# - 迁移旧版ConfigMap到配置文件是因为0.11.6-beta之前版本的helm chart将各个配置文件存储在k8s的ConfigMap中， +# 由于功能复杂度提升，自0.11.6-beta版本开始配置文件采用文件形式存储到存储卷中。 +# 从旧版升级来的用户会通过这个脚本自动执行配置的迁移。 +# +# - 需要调整adapter的配置文件的原因是: +# 1. core的Service的DNS名称是动态的（由安装实例名拼接），无法在adapter的配置文件中提前确定。 +# 用于对外连接的maibot_server.host和maibot_server.port字段，会被替换为core的Service对应的DNS名称和8000端口（硬编码，用户无需配置）。 +# 2. 为了使adapter监听所有地址以及保持chart中配置的端口号，需要在adapter的配置文件中覆盖这些配置。 +# 用于监听的napcat_server.host和napcat_server.port字段，会被替换为0.0.0.0和8095端口（实际映射到的Service端口会在Service中配置）。 +# +# - 需要调整core的配置文件的原因是： +# 1. core的WebUI启停需要由helm chart控制，以便正常创建Service和Ingress资源。 +# 配置文件中的webui.enabled、webui.allowed_ips将由此脚本覆盖为正确配置。 +# 2. core的maim_message的api server现在可以作为k8s服务暴露出来。监听的IP和端口需要由helm chart控制，以便Service正确映射。 +# 配置文件中的maim_message.enable_api_server、maim_message.api_server_host、maim_message.api_server_port将由此脚本覆盖为正确配置。 + +import os +import toml +import time +import base64 +from kubernetes import client, config +from kubernetes.client.exceptions import ApiException +from datetime import datetime, timezone + +config.load_incluster_config() +core_api = client.CoreV1Api() +apps_api = client.AppsV1Api() + +# 读取部署的关键信息 +with open("/var/run/secrets/kubernetes.io/serviceaccount/namespace", 'r') as f: + namespace = f.read().strip() +release_name = os.getenv("RELEASE_NAME").strip() +is_webui_enabled = os.getenv("IS_WEBUI_ENABLED").lower() == "true" +is_maim_message_api_server_enabled = os.getenv("IS_MMSG_ENABLED").lower() == "true" +config_adapter_b64 = os.getenv("CONFIG_ADAPTER_B64") +config_core_env_b64 = os.getenv("CONFIG_CORE_ENV_B64") +config_core_bot_b64 = os.getenv("CONFIG_CORE_BOT_B64") +config_core_model_b64 = os.getenv("CONFIG_CORE_MODEL_B64") + + +def log(func: str, msg: str, level: str = 'INFO'): + print(f'[{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}] [{level}] [{func}] {msg}') + + +def migrate_old_config(): + """迁移旧版配置""" + func_name = 'migrate_old_config' + log(func_name, 'Checking whether there are old configmaps to migrate...') + old_configmap_version = None + status_migrating = { # 存储adapter的config.toml、core的bot_config.toml和model_config.toml三个文件的迁移状态 + 'adapter_config.toml': False, + 'core_bot_config.toml': False, + 'core_model_config.toml': False + } + + # 如果存储卷中已存在配置文件，则跳过迁移 + if os.path.isfile('/app/config/core/bot_config.toml') or os.path.isfile('/app/config/core/model_config.toml') or \ + os.path.isfile('/app/config/adapter/config.toml'): + log(func_name, 'Found existing config file(s) in PV. Migration will be ignored. Done.') + return + + def migrate_cm_to_file(cm_name: str, key_name: str, file_path: str) -> bool: + """检测是否有指定名称的configmap，如果有的话备份到指定的配置文件里并删除configmap，返回是否已备份""" + try: + cm = core_api.read_namespaced_config_map( + name=cm_name, + namespace=namespace + ) + log(func_name, f'\tMigrating `{key_name}` of `{cm_name}`...') + with open(file_path, 'w', encoding='utf-8') as _f: + _f.write(cm.data[key_name]) + core_api.delete_namespaced_config_map( + name=cm_name, + namespace=namespace + ) + log(func_name, f'\tSuccessfully migrated `{key_name}` of `{cm_name}`.') + except ApiException as e: + if e.status == 404: + return False + return True + + # 对于0.11.5-beta版本，adapter的config.toml、core的bot_config.toml和model_config.toml均存储于不同的ConfigMap，需要依次迁移 + if True not in status_migrating.values(): + status_migrating['adapter_config.toml'] = migrate_cm_to_file(f'{release_name}-maibot-adapter-config', + 'config.toml', + '/app/config/adapter/config.toml') + status_migrating['core_bot_config.toml'] = migrate_cm_to_file(f'{release_name}-maibot-core-bot-config', + 'bot_config.toml', + '/app/config/core/bot_config.toml') + status_migrating['core_model_config.toml'] = migrate_cm_to_file(f'{release_name}-maibot-core-model-config', + 'model_config.toml', + '/app/config/core/model_config.toml') + if True in status_migrating.values(): + old_configmap_version = '0.11.5-beta' + + # 对于低于0.11.5-beta的版本，adapter的1个配置和core的3个配置位于各自的configmap中 + if True not in status_migrating.values(): + status_migrating['adapter_config.toml'] = migrate_cm_to_file(f'{release_name}-maibot-adapter', + 'config.toml', + '/app/config/adapter/config.toml') + status_migrating['core_bot_config.toml'] = migrate_cm_to_file(f'{release_name}-maibot-core', + 'bot_config.toml', + '/app/config/core/bot_config.toml') + status_migrating['core_model_config.toml'] = migrate_cm_to_file(f'{release_name}-maibot-core', + 'model_config.toml', + '/app/config/core/model_config.toml') + if True in status_migrating.values(): + old_configmap_version = 'before 0.11.5-beta' + + if old_configmap_version: + log(func_name, f'Migrating status for version `{old_configmap_version}`:') + for k, v in status_migrating.items(): + log(func_name, f'\t{k}: {v}') + if False in status_migrating.values(): + log(func_name, 'There is/are config(s) that not been migrated. Please check the config manually.', + level='WARNING') + else: + log(func_name, 'Successfully migrated old configs. Done.') + else: + log(func_name, 'Old config not found. Ignoring migration. Done.') + + +def write_config_files(): + """当注入了配置文件时（一般是首次安装或者用户指定覆盖），将helm chart注入的配置写入存储卷中的实际文件""" + func_name = 'write_config_files' + log(func_name, 'Detecting config files...') + if config_adapter_b64: + log(func_name, '\tWriting `config.toml` of adapter...') + config_str = base64.b64decode(config_adapter_b64).decode("utf-8") + with open('/app/config/adapter/config.toml', 'w', encoding='utf-8') as _f: + _f.write(config_str) + log(func_name, '\t`config.toml` of adapter wrote.') + if True: # .env直接覆盖 + log(func_name, '\tWriting .env file of core...') + config_str = base64.b64decode(config_core_env_b64).decode("utf-8") + with open('/app/config/core/.env', 'w', encoding='utf-8') as _f: + _f.write(config_str) + log(func_name, '\t`.env` of core wrote.') + if config_core_bot_b64: + log(func_name, '\tWriting `bot_config.toml` of core...') + config_str = base64.b64decode(config_core_bot_b64).decode("utf-8") + with open('/app/config/core/bot_config.toml', 'w', encoding='utf-8') as _f: + _f.write(config_str) + log(func_name, '\t`bot_config.toml` of core wrote.') + if config_core_model_b64: + log(func_name, '\tWriting `model_config.toml` of core...') + config_str = base64.b64decode(config_core_model_b64).decode("utf-8") + with open('/app/config/core/model_config.toml', 'w', encoding='utf-8') as _f: + _f.write(config_str) + log(func_name, '\t`model_config.toml` of core wrote.') + log(func_name, 'Detection done.') + + +def reconfigure_adapter(): + """调整adapter的配置文件的napcat_server和maibot_server字段，使其Service能被napcat连接以及连接到core的Service""" + func_name = 'reconfigure_adapter' + log(func_name, 'Reconfiguring `config.toml` of adapter...') + with open('/app/config/adapter/config.toml', 'r', encoding='utf-8') as _f: + config_adapter = toml.load(_f) + config_adapter.setdefault('napcat_server', {}) + config_adapter['napcat_server']['host'] = '0.0.0.0' + config_adapter['napcat_server']['port'] = 8095 + config_adapter.setdefault('maibot_server', {}) + config_adapter['maibot_server']['host'] = f'{release_name}-maibot-core' # 根据release名称动态拼接core服务的DNS名称 + config_adapter['maibot_server']['port'] = 8000 + with open('/app/config/adapter/config.toml', 'w', encoding='utf-8') as _f: + _f.write(toml.dumps(config_adapter)) + log(func_name, 'Reconfiguration done.') + + +def reconfigure_core(): + """调整core的配置文件的webui和maim_message字段，使其服务能被正确映射""" + func_name = 'reconfigure_core' + log(func_name, 'Reconfiguring `bot_config.toml` of core...') + with open('/app/config/core/bot_config.toml', 'r', encoding='utf-8') as _f: + config_core = toml.load(_f) + config_core.setdefault('webui', {}) + config_core['webui']['enabled'] = is_webui_enabled + config_core['webui']['allowed_ips'] = '0.0.0.0/0' # 部署于k8s内网，使用宽松策略 + config_core.setdefault('maim_message', {}) + config_core['maim_message']['enable_api_server'] = is_maim_message_api_server_enabled + config_core['maim_message']['api_server_host'] = '0.0.0.0' + config_core['maim_message']['api_server_port'] = 8090 + with open('/app/config/core/bot_config.toml', 'w', encoding='utf-8') as _f: + _f.write(toml.dumps(config_core)) + log(func_name, 'Reconfiguration done.') + + +def _scale_statefulsets(statefulsets: list[str], replicas: int, wait: bool = False, timeout: int = 300): + """调整指定几个statefulset的副本数，wait参数控制是否等待调整完成再返回""" + statefulsets = set(statefulsets) + for name in statefulsets: + apps_api.patch_namespaced_stateful_set_scale( + name=name, + namespace=namespace, + body={"spec": {"replicas": replicas}} + ) + if not wait: + return + + start_time = time.time() + while True: + remaining_pods = [] + + pods = core_api.list_namespaced_pod(namespace).items + + for pod in pods: + owners = pod.metadata.owner_references or [] + for owner in owners: + if owner.kind == "StatefulSet" and owner.name in statefulsets: + remaining_pods.append(pod.metadata.name) + + if not remaining_pods: + return + + elapsed = time.time() - start_time + if elapsed > timeout: + raise TimeoutError( + f"Timeout waiting for Pods to be deleted. " + f"Remaining Pods: {remaining_pods}" + ) + time.sleep(5) + + +def _restart_statefulset(name: str, ignore_error: bool = False): + """重启指定的statefulset""" + now = datetime.now(timezone.utc).isoformat() + body = { + "spec": { + "template": { + "metadata": { + "annotations": { + "kubectl.kubernetes.io/restartedAt": now + } + } + } + } + } + try: + apps_api.patch_namespaced_stateful_set( + name=name, + namespace=namespace, + body=body + ) + except ApiException as e: + if ignore_error: + pass + else: + raise e + + +if __name__ == '__main__': + log('main', 'Start to process data before install/upgrade...') + log('main', 'Scaling adapter and core to 0...') + _scale_statefulsets([f'{release_name}-maibot-adapter', f'{release_name}-maibot-core'], 0, wait=True) + migrate_old_config() + write_config_files() + reconfigure_adapter() + reconfigure_core() + log('main', 'Scaling adapter and core to 1...') + _scale_statefulsets([f'{release_name}-maibot-adapter', f'{release_name}-maibot-core'], 1) + log('main', 'Process done.') diff --git a/helm-chart/adapter-cm-generator/requirements.txt b/helm-chart/preprocessor/requirements.txt similarity index 100% rename from helm-chart/adapter-cm-generator/requirements.txt rename to helm-chart/preprocessor/requirements.txt diff --git a/helm-chart/templates/adapter/pvc.yaml b/helm-chart/templates/adapter/pvc.yaml index 61778630..4bc24506 100644 --- a/helm-chart/templates/adapter/pvc.yaml +++ b/helm-chart/templates/adapter/pvc.yaml @@ -4,13 +4,30 @@ metadata: name: {{ .Release.Name }}-maibot-adapter namespace: {{ .Release.Namespace }} spec: - {{- if .Values.adapter.persistence.accessModes }} + {{- if .Values.adapter.persistence.data.accessModes }} accessModes: - {{ toYaml .Values.adapter.persistence.accessModes | nindent 4 }} + {{ toYaml .Values.adapter.persistence.data.accessModes | nindent 4 }} {{- end }} resources: requests: - storage: {{ .Values.adapter.persistence.size }} - {{- if .Values.adapter.persistence.storageClass }} - storageClassName: {{ .Values.adapter.persistence.storageClass | default nil }} + storage: {{ .Values.adapter.persistence.data.size }} + {{- if .Values.adapter.persistence.data.storageClass }} + storageClassName: {{ .Values.adapter.persistence.data.storageClass | default nil }} + {{- end }} +--- +apiVersion: v1 +kind: PersistentVolumeClaim +metadata: + name: {{ .Release.Name }}-maibot-adapter-config + namespace: {{ .Release.Namespace }} +spec: + {{- if .Values.adapter.persistence.config.accessModes }} + accessModes: + {{ toYaml .Values.adapter.persistence.config.accessModes | nindent 4 }} + {{- end }} + resources: + requests: + storage: {{ .Values.adapter.persistence.config.size }} + {{- if .Values.adapter.persistence.config.storageClass }} + storageClassName: {{ .Values.adapter.persistence.config.storageClass | default nil }} {{- end }} diff --git a/helm-chart/templates/adapter/statefulset.yaml b/helm-chart/templates/adapter/statefulset.yaml index 0d9b76da..ec914b16 100644 --- a/helm-chart/templates/adapter/statefulset.yaml +++ b/helm-chart/templates/adapter/statefulset.yaml @@ -7,7 +7,7 @@ metadata: app: {{ .Release.Name }}-maibot-adapter spec: serviceName: {{ .Release.Name }}-maibot-adapter - replicas: 1 + replicas: 0 # post-install任务初始化完毕后自动扩容至1 selector: matchLabels: app: {{ .Release.Name }}-maibot-adapter @@ -21,7 +21,7 @@ spec: env: - name: TZ value: Asia/Shanghai - image: {{ .Values.adapter.image.repository | default "unclas/maimbot-adapter" }}:{{ .Values.adapter.image.tag | default "main-20250924053857" }} + image: {{ .Values.adapter.image.repository | default "unclas/maimbot-adapter" }}:{{ .Values.adapter.image.tag | default "main-20251211074617" }} imagePullPolicy: {{ .Values.adapter.image.pullPolicy }} ports: - containerPort: 8095 @@ -36,7 +36,6 @@ spec: name: data - mountPath: /adapters/config.toml name: config - readOnly: true subPath: config.toml {{- if .Values.adapter.image.pullSecrets }} imagePullSecrets: @@ -54,9 +53,6 @@ spec: - name: data persistentVolumeClaim: claimName: {{ .Release.Name }}-maibot-adapter - - configMap: - items: - - key: config.toml - path: config.toml - name: {{ .Release.Name }}-maibot-adapter-config - name: config + - name: config + persistentVolumeClaim: + claimName: {{ .Release.Name }}-maibot-adapter-config diff --git a/helm-chart/templates/core/configmap-bot-config.yaml b/helm-chart/templates/core/configmap-bot-config.yaml deleted file mode 100644 index d1395296..00000000 --- a/helm-chart/templates/core/configmap-bot-config.yaml +++ /dev/null @@ -1,14 +0,0 @@ -{{- if or .Release.IsInstall (and .Values.core.webui.enabled .Values.config.enable_config_override_with_webui) (and (not .Values.core.webui.enabled) .Values.config.enable_config_override_without_webui) }} -# 渲染规则： -# 初次安装，或配置了覆盖规则 -apiVersion: v1 -kind: ConfigMap -metadata: - name: {{ .Release.Name }}-maibot-core-bot-config - namespace: {{ .Release.Namespace }} - annotations: - "helm.sh/resource-policy": keep -data: - bot_config.toml: | - {{ .Values.config.core_bot_config | nindent 4 }} -{{- end }} diff --git a/helm-chart/templates/core/configmap-env-config.yaml b/helm-chart/templates/core/configmap-env-config.yaml deleted file mode 100644 index 17b1d627..00000000 --- a/helm-chart/templates/core/configmap-env-config.yaml +++ /dev/null @@ -1,13 +0,0 @@ -apiVersion: v1 -kind: ConfigMap -metadata: - name: {{ .Release.Name }}-maibot-core-env-config - namespace: {{ .Release.Namespace }} -data: - .env: | - HOST=0.0.0.0 - PORT=8000 - WEBUI_ENABLED={{ if .Values.core.webui.enabled }}true{{ else }}false{{ end }} - WEBUI_MODE=production - WEBUI_HOST=0.0.0.0 - WEBUI_PORT=8001 diff --git a/helm-chart/templates/core/configmap-model-config.yaml b/helm-chart/templates/core/configmap-model-config.yaml deleted file mode 100644 index bf122244..00000000 --- a/helm-chart/templates/core/configmap-model-config.yaml +++ /dev/null @@ -1,14 +0,0 @@ -{{- if or .Release.IsInstall (and .Values.core.webui.enabled .Values.config.enable_config_override_with_webui) (and (not .Values.core.webui.enabled) .Values.config.enable_config_override_without_webui) }} -# 渲染规则： -# 初次安装，或配置了覆盖规则 -apiVersion: v1 -kind: ConfigMap -metadata: - name: {{ .Release.Name }}-maibot-core-model-config - namespace: {{ .Release.Namespace }} - annotations: - "helm.sh/resource-policy": keep -data: - model_config.toml: | - {{ .Values.config.core_model_config | nindent 4 }} -{{- end }} diff --git a/helm-chart/templates/core/pvc.yaml b/helm-chart/templates/core/pvc.yaml index e7fe15c7..66c6ac12 100644 --- a/helm-chart/templates/core/pvc.yaml +++ b/helm-chart/templates/core/pvc.yaml @@ -4,13 +4,30 @@ metadata: name: {{ .Release.Name }}-maibot-core namespace: {{ .Release.Namespace }} spec: - {{- if .Values.core.persistence.accessModes }} + {{- if .Values.core.persistence.data.accessModes }} accessModes: - {{ toYaml .Values.core.persistence.accessModes | nindent 4 }} + {{ toYaml .Values.core.persistence.data.accessModes | nindent 4 }} {{- end }} resources: requests: - storage: {{ .Values.core.persistence.size }} - {{- if .Values.core.persistence.storageClass }} - storageClassName: {{ .Values.core.persistence.storageClass | default nil }} + storage: {{ .Values.core.persistence.data.size }} + {{- if .Values.core.persistence.data.storageClass }} + storageClassName: {{ .Values.core.persistence.data.storageClass | default nil }} + {{- end }} +--- +apiVersion: v1 +kind: PersistentVolumeClaim +metadata: + name: {{ .Release.Name }}-maibot-core-config + namespace: {{ .Release.Namespace }} +spec: + {{- if .Values.core.persistence.config.accessModes }} + accessModes: + {{ toYaml .Values.core.persistence.config.accessModes | nindent 4 }} + {{- end }} + resources: + requests: + storage: {{ .Values.core.persistence.config.size }} + {{- if .Values.core.persistence.config.storageClass }} + storageClassName: {{ .Values.core.persistence.config.storageClass | default nil }} {{- end }} diff --git a/helm-chart/templates/core/service.yaml b/helm-chart/templates/core/service.yaml index 5b67de50..2a049eeb 100644 --- a/helm-chart/templates/core/service.yaml +++ b/helm-chart/templates/core/service.yaml @@ -20,6 +20,15 @@ spec: nodePort: {{ .Values.core.webui.service.nodePort | default nil }} {{- end }} {{- end }} + {{- if .Values.core.maim_message_api_server.enabled }} + - name: maim-message + port: {{ .Values.core.maim_message_api_server.service.port }} + protocol: TCP + targetPort: 8090 + {{- if eq .Values.core.maim_message_api_server.service.type "NodePort" }} + nodePort: {{ .Values.core.maim_message_api_server.service.nodePort | default nil }} + {{- end }} + {{- end }} selector: app: {{ .Release.Name }}-maibot-core type: ClusterIP diff --git a/helm-chart/templates/core/statefulset.yaml b/helm-chart/templates/core/statefulset.yaml index 2bc8d14c..50fed52d 100644 --- a/helm-chart/templates/core/statefulset.yaml +++ b/helm-chart/templates/core/statefulset.yaml @@ -7,7 +7,7 @@ metadata: app: {{ .Release.Name }}-maibot-core spec: serviceName: {{ .Release.Name }}-maibot-core - replicas: 1 + replicas: 0 # post-install任务初始化完毕后自动扩容至1 selector: matchLabels: app: {{ .Release.Name }}-maibot-core @@ -26,14 +26,10 @@ spec: - name: TZ value: "Asia/Shanghai" - name: EULA_AGREE - value: "99f08e0cab0190de853cb6af7d64d4de" + value: "1b662741904d7155d1ce1c00b3530d0d" - name: PRIVACY_AGREE value: "9943b855e72199d0f5016ea39052f1b6" - {{- if .Values.core.webui.enabled }} - - name: MAIBOT_WEBUI_ENABLED - value: "true" - {{- end}} - image: {{ .Values.core.image.repository | default "sengokucola/maibot" }}:{{ .Values.core.image.tag | default "0.11.5-beta" }} + image: {{ .Values.core.image.repository | default "sengokucola/maibot" }}:{{ .Values.core.image.tag | default "0.12.0" }} imagePullPolicy: {{ .Values.core.image.pullPolicy }} ports: - containerPort: 8000 @@ -56,59 +52,21 @@ spec: readOnly: true subPath: k8s-init.sh - mountPath: /MaiMBot/.env - name: env-config - readOnly: true + name: config subPath: .env - {{- if not .Values.core.webui.enabled }} - mountPath: /MaiMBot/config/model_config.toml - name: model-config - readOnly: true + name: config subPath: model_config.toml - mountPath: /MaiMBot/config/bot_config.toml - name: bot-config - readOnly: true + name: config subPath: bot_config.toml - {{- end }} + - mountPath: /MaiMBot/adapters-config/config.toml # WebUI修改adapter配置所用 + name: adapter-config + subPath: config.toml {{- if .Values.statistics_dashboard.enabled }} - mountPath: /MaiMBot/statistics name: statistics {{- end }} - {{- if .Values.core.webui.enabled }} - - mountPath: /MaiMBot/webui-cm-sync - name: webui-cm-sync - {{- end }} - {{- if .Values.core.webui.enabled }} - - name: webui-cm-sync - image: {{ .Values.core.webui.cm_sync.image.repository | default "reg.mikumikumi.xyz/maibot/core-webui-cm-sync" }}:{{ .Values.core.webui.cm_sync.image.tag | default "0.11.5-beta" }} - imagePullPolicy: {{ .Values.core.webui.cm_sync.image.pullPolicy }} - env: - - name: PYTHONUNBUFFERED - value: "1" - - name: RELEASE_NAME - value: {{ .Release.Name }} - volumeMounts: - - mountPath: /MaiMBot/webui-cm-sync - name: webui-cm-sync - {{- end }} - {{- if .Values.core.setup_default_plugins }} - initContainers: # 用户插件目录存储在存储卷中，会在启动时覆盖掉容器的默认插件目录。此初始化容器用于默认插件更新后或麦麦首次启动时为用户自动安装默认插件到存储卷中 - - args: - - setup-plugins.py - command: - - python3 - workingDir: /MaiMBot - image: {{ .Values.core.image.repository | default "sengokucola/maibot" }}:{{ .Values.core.image.tag | default "0.11.5-beta" }} - imagePullPolicy: {{ .Values.core.image.pullPolicy }} - name: setup-plugins - resources: { } - volumeMounts: - - mountPath: /MaiMBot/data - name: data - - mountPath: /MaiMBot/setup-plugins.py - name: scripts - readOnly: true - subPath: setup-plugins.py - {{- end }} serviceAccountName: {{ .Release.Name }}-maibot-sa {{- if .Values.core.image.pullSecrets }} imagePullSecrets: @@ -130,38 +88,16 @@ spec: items: - key: k8s-init.sh path: k8s-init.sh - {{- if .Values.core.setup_default_plugins }} - - key: setup-plugins.py - path: setup-plugins.py - {{- end }} name: {{ .Release.Name }}-maibot-scripts name: scripts - - configMap: - items: - - key: .env - path: .env - name: {{ .Release.Name }}-maibot-core-env-config - name: env-config - {{- if not .Values.core.webui.enabled }} - - configMap: - items: - - key: model_config.toml - path: model_config.toml - name: {{ .Release.Name }}-maibot-core-model-config - name: model-config - - configMap: - items: - - key: bot_config.toml - path: bot_config.toml - name: {{ .Release.Name }}-maibot-core-bot-config - name: bot-config - {{- end }} + - name: config + persistentVolumeClaim: + claimName: {{ .Release.Name }}-maibot-core-config + - name: adapter-config + persistentVolumeClaim: + claimName: {{ .Release.Name }}-maibot-adapter-config {{- if .Values.statistics_dashboard.enabled }} - name: statistics persistentVolumeClaim: claimName: {{ .Release.Name }}-maibot-statistics-dashboard {{- end }} - {{- if .Values.core.webui.enabled }} - - emptyDir: {} - name: webui-cm-sync - {{- end }} diff --git a/helm-chart/templates/napcat/statefulset.yaml b/helm-chart/templates/napcat/statefulset.yaml index 7cca56df..dc022b21 100644 --- a/helm-chart/templates/napcat/statefulset.yaml +++ b/helm-chart/templates/napcat/statefulset.yaml @@ -26,7 +26,7 @@ spec: value: "{{ .Values.napcat.permission.uid }}" - name: TZ value: Asia/Shanghai - image: {{ .Values.napcat.image.repository | default "mlikiowa/napcat-docker" }}:{{ .Values.napcat.image.tag | default "v4.9.73" }} + image: {{ .Values.napcat.image.repository | default "mlikiowa/napcat-docker" }}:{{ .Values.napcat.image.tag | default "v4.9.80" }} imagePullPolicy: {{ .Values.napcat.image.pullPolicy }} livenessProbe: failureThreshold: 3 diff --git a/helm-chart/templates/other/check-eula-privacy.yaml b/helm-chart/templates/other/check-eula-privacy.yaml index 18b0cca2..db997a60 100644 --- a/helm-chart/templates/other/check-eula-privacy.yaml +++ b/helm-chart/templates/other/check-eula-privacy.yaml @@ -1,8 +1,8 @@ # 检查EULA和PRIVACY {{- if not .Values.EULA_AGREE }} -{{- fail "You must accept the EULA by setting 'EULA_AGREE: true'. EULA: https://github.com/MaiM-with-u/MaiBot/blob/main/EULA.md" }} +{{ fail "You must accept the EULA by setting 'EULA_AGREE: true'. EULA: https://github.com/Mai-with-u/MaiBot/blob/main/EULA.md" }} {{- end }} {{- if not .Values.PRIVACY_AGREE }} -{{- fail "You must accept the Privacy Policy by setting 'PRIVACY_AGREE: true'. Privacy Policy: https://github.com/MaiM-with-u/MaiBot/blob/main/PRIVACY.md" }} +{{ fail "You must accept the Privacy Policy by setting 'PRIVACY_AGREE: true'. Privacy Policy: https://github.com/Mai-with-u/MaiBot/blob/main/PRIVACY.md" }} {{- end }} diff --git a/helm-chart/templates/other/configmap-scripts.yaml b/helm-chart/templates/other/configmap-scripts.yaml index dd61ca68..3fe96794 100644 --- a/helm-chart/templates/other/configmap-scripts.yaml +++ b/helm-chart/templates/other/configmap-scripts.yaml @@ -7,8 +7,3 @@ data: # core k8s-init.sh: | {{ .Files.Get "files/k8s-init.sh" | nindent 4 }} - # core的初始化容器 - {{- if .Values.core.setup_default_plugins }} - setup-plugins.py: | - {{ .Files.Get "files/setup-plugins.py" | nindent 4 }} - {{- end }} diff --git a/helm-chart/templates/other/job-gen-adapter-cm.yaml b/helm-chart/templates/other/job-gen-adapter-cm.yaml deleted file mode 100644 index ad01b568..00000000 --- a/helm-chart/templates/other/job-gen-adapter-cm.yaml +++ /dev/null @@ -1,30 +0,0 @@ -# 动态生成adapter配置文件的configmap的job，仅会在部署时运行一次 -apiVersion: batch/v1 -kind: Job -metadata: - name: {{ .Release.Name }}-maibot-adapter-cm-generator - namespace: {{ .Release.Namespace }} - annotations: - "helm.sh/hook": post-install,post-upgrade - "helm.sh/hook-delete-policy": before-hook-creation,hook-succeeded -spec: - backoffLimit: 2 - template: - spec: - serviceAccountName: {{ .Release.Name }}-maibot-sa - restartPolicy: Never - containers: - - name: adapter-cm-generator - image: {{ .Values.adapter.cm_generator.image.repository | default "reg.mikumikumi.xyz/maibot/adapter-cm-generator" }}:{{ .Values.adapter.cm_generator.image.tag | default "0.11.5-beta" }} - workingDir: /app - env: - - name: PYTHONUNBUFFERED - value: "1" - - name: NAMESPACE - valueFrom: - fieldRef: - fieldPath: metadata.namespace - - name: RELEASE_NAME - value: {{ .Release.Name }} - - name: DATA_B64 - value: {{ .Values.config.adapter_config | b64enc }} # 将配置文件编码为base64，从环境变量注入 diff --git a/helm-chart/templates/other/job-preprocessor.yaml b/helm-chart/templates/other/job-preprocessor.yaml new file mode 100644 index 00000000..8545f5af --- /dev/null +++ b/helm-chart/templates/other/job-preprocessor.yaml @@ -0,0 +1,62 @@ +# 预处理脚本，仅会在部署前运行一次 +apiVersion: batch/v1 +kind: Job +metadata: + name: {{ .Release.Name }}-maibot-preprocessor + namespace: {{ .Release.Namespace }} + annotations: + "helm.sh/hook": post-install,post-upgrade + "helm.sh/hook-delete-policy": before-hook-creation,hook-succeeded +spec: + backoffLimit: 2 + template: + spec: + serviceAccountName: {{ .Release.Name }}-maibot-sa + restartPolicy: Never + containers: + - name: preprocessor + image: {{ .Values.pre_processor.image.repository | default "reg.mikumikumi.xyz/maibot/preprocessor" }}:{{ .Values.pre_processor.image.tag | default "0.12.0" }} + imagePullPolicy: {{ .Values.pre_processor.image.pullPolicy }} + env: + - name: RELEASE_NAME + value: {{ .Release.Name }} + - name: IS_WEBUI_ENABLED + value: {{ .Values.core.webui.enabled | quote }} + - name: IS_MMSG_ENABLED + value: {{ .Values.core.maim_message_api_server.enabled | quote }} + {{- if or .Values.config.override_adapter_config .Release.IsInstall }} + - name: CONFIG_ADAPTER_B64 + value: {{ .Values.config.adapter_config | b64enc | quote }} + {{- end }} + - name: CONFIG_CORE_ENV_B64 + value: {{ tpl (.Files.Get "files/.env") . | b64enc | quote }} + {{- if or .Values.config.override_core_bot_config .Release.IsInstall }} + - name: CONFIG_CORE_BOT_B64 + value: {{ .Values.config.core_bot_config | b64enc | quote }} + {{- end }} + {{- if or .Values.config.override_core_model_config .Release.IsInstall }} + - name: CONFIG_CORE_MODEL_B64 + value: {{ .Values.config.core_model_config | b64enc | quote }} + {{- end }} + volumeMounts: + - mountPath: /app/config/adapter + name: adapter-config + - mountPath: /app/config/core + name: core-config + imagePullSecrets: + {{ toYaml .Values.pre_processor.image.pullSecrets | nindent 8 }} + {{- if .Values.pre_processor.nodeSelector }} + nodeSelector: + {{ toYaml .Values.pre_processor.nodeSelector | nindent 8 }} + {{- end }} + {{- if .Values.pre_processor.tolerations }} + tolerations: + {{ toYaml .Values.pre_processor.tolerations | nindent 8 }} + {{- end }} + volumes: + - name: adapter-config + persistentVolumeClaim: + claimName: {{ .Release.Name }}-maibot-adapter-config + - name: core-config + persistentVolumeClaim: + claimName: {{ .Release.Name }}-maibot-core-config diff --git a/helm-chart/templates/other/rbac.yaml b/helm-chart/templates/other/rbac.yaml index 8b8075c7..2edb11b4 100644 --- a/helm-chart/templates/other/rbac.yaml +++ b/helm-chart/templates/other/rbac.yaml @@ -12,11 +12,14 @@ metadata: namespace: {{ .Release.Namespace }} rules: - apiGroups: [""] - resources: ["configmaps"] - verbs: ["get", "list", "create", "update", "patch"] + resources: ["configmaps", "pods"] + verbs: ["get", "list", "delete"] - apiGroups: ["apps"] resources: ["statefulsets"] - verbs: ["get", "list", "create", "update", "patch"] + verbs: ["get", "list", "update", "patch"] + - apiGroups: ["apps"] + resources: ["statefulsets/scale"] + verbs: ["get", "patch", "update"] --- apiVersion: rbac.authorization.k8s.io/v1 kind: RoleBinding diff --git a/helm-chart/values.yaml b/helm-chart/values.yaml index dacb8c3d..92e84a6e 100644 --- a/helm-chart/values.yaml +++ b/helm-chart/values.yaml @@ -5,12 +5,23 @@ EULA_AGREE: false PRIVACY_AGREE: false +# 预处理Job的配置 +pre_processor: + image: + repository: # 默认 reg.mikumikumi.xyz/maibot/preprocessor + tag: # 默认 0.12.0 + pullPolicy: IfNotPresent + pullSecrets: [ ] + + nodeSelector: { } + tolerations: [ ] + # 麦麦Adapter的部署配置 adapter: image: repository: # 默认 unclas/maimbot-adapter - tag: # 默认 main-20250924053857 + tag: # 默认 main-20251211074617 pullPolicy: IfNotPresent pullSecrets: [ ] @@ -29,26 +40,23 @@ adapter: nodePort: # 仅在设置NodePort类型时有效，不指定则会随机分配端口 persistence: - storageClass: - accessModes: - - ReadWriteOnce - size: 1Gi - - # adapter的动态生成configmap的Job的配置 - cm_generator: - image: - repository: # 默认 reg.mikumikumi.xyz/maibot/adapter-cm-generator - tag: # 默认 0.11.5-beta - pullPolicy: IfNotPresent - pullSecrets: [ ] - + config: # 配置文件的存储卷 + storageClass: + accessModes: + - ReadWriteOnce + size: 10Mi + data: # 数据的存储卷 + storageClass: + accessModes: + - ReadWriteOnce + size: 1Gi # 麦麦本体的部署配置 core: image: repository: # 默认 sengokucola/maibot - tag: # 默认 0.11.5-beta + tag: # 默认 0.12.0 pullPolicy: IfNotPresent pullSecrets: [ ] @@ -58,23 +66,19 @@ core: tolerations: [ ] persistence: - storageClass: - accessModes: - - ReadWriteOnce - size: 10Gi - - setup_default_plugins: true # 启用一个初始化容器，用于为用户自动安装默认插件到存储卷中 + config: # 配置文件的存储卷 + storageClass: + accessModes: + - ReadWriteOnce + size: 10Mi + data: # 数据的存储卷 + storageClass: + accessModes: + - ReadWriteOnce + size: 10Gi webui: # WebUI相关配置 - # 对从helm chart 0.11.5-beta 之前的旧版升级的用户的重要提示： - # 旧版本helm chart没有配置configmap的保留策略，直接升级同时开启WebUI后会导致configmap丢失从而无法启动。 - # 这种情况可以先禁用WebUI更新一次，再启用WebUI更新一次即可解决问题。 enabled: true # 默认启用 - cm_sync: # WebUI的辅助容器配置 - image: - repository: # 默认 reg.mikumikumi.xyz/maibot/core-webui-cm-sync - tag: # 默认 0.11.5-beta - pullPolicy: IfNotPresent service: type: ClusterIP # ClusterIP / NodePort 指定NodePort可以将内网的服务端口映射到物理节点的端口 port: 8001 # 服务端口 @@ -87,6 +91,14 @@ core: path: / pathType: Prefix + maim_message_api_server: + enabled: false + service: + type: ClusterIP # ClusterIP / NodePort 指定NodePort可以将内网的服务端口映射到物理节点的端口 + port: 8090 # 服务端口 + nodePort: # 仅在设置NodePort类型时有效，不指定则会随机分配端口 + + # 麦麦的运行统计看板配置 # 麦麦每隔一段时间会自动输出html格式的运行统计报告，此统计报告可以作为静态网页访问 # 此功能默认禁用。如果你认为报告可以被公开访问（报告包含联系人/群组名称、模型token花费信息等），则可以启用此功能 @@ -139,7 +151,7 @@ napcat: image: repository: # 默认 mlikiowa/napcat-docker - tag: # 默认 v4.9.73 + tag: # 默认 v4.9.91 pullPolicy: IfNotPresent pullSecrets: [ ] @@ -211,15 +223,17 @@ sqlite_web: path: / pathType: Prefix -# 手动设置麦麦各部分组件的运行配置文件 +# 设置麦麦各部分组件的初始运行配置 +# 考虑到配置文件的操作复杂性增加，k8s的适配复杂度也同步增加，且WebUI可以直接修改配置文件 +# 自0.11.6-beta版本开始，各组件的配置不再存储于k8s的configmap中，而是直接存储于存储卷的实际文件中 +# 从旧版本升级的用户，旧的configmap的配置会自动迁移到新的存储卷的配置文件中 +# 此处的配置只在初次部署时或者指定覆盖时注入到MaiBot中 config: - # 启用WebUI后，配置文件的修改即可在WebUI进行。如果通过WebUI修改了配置，则实际的配置文件将与values中的配置存在差异。 - # 如果用户在k8s的ConfigMap中手动修改了配置文件，则实际的配置文件也会与values中的配置存在差异。 - # 出现上述两种情况时，为了避免helm升级麦麦时，下面values中的配置覆盖掉已有的配置文件而导致配置丢失，可以在这里禁止本次部署时的配置覆盖。 - # 注：由于adapter的配置无法通过WebUI修改，因此下面的adapter_config配置仍然会覆盖已有配置文件。 - enable_config_override_without_webui: true # 未启用WebUI时，默认覆盖 - enable_config_override_with_webui: false # 启用WebUI时，默认不覆盖 + # 指定是否用下面的配置覆盖MaiBot现有的配置文件 + override_adapter_config: false + override_core_bot_config: false + override_core_model_config: false # adapter的config.toml adapter_config: | @@ -256,7 +270,7 @@ config: # core的model_config.toml core_model_config: | [inner] - version = "1.7.8" + version = "1.9.1" # 配置文件版本号迭代规则同bot_config.toml @@ -303,7 +317,7 @@ config: api_provider = "DeepSeek" # API服务商名称（对应在api_providers中配置的服务商名称） price_in = 2.0 # 输入价格（用于API调用统计，单位：元/ M token）（可选，若无该字段，默认值为0） price_out = 8.0 # 输出价格（用于API调用统计，单位：元/ M token）（可选，若无该字段，默认值为0） - #force_stream_mode = true # 强制流式输出模式（若模型不支持非流式输出，请取消该注释，启用强制流式输出，若无该字段，默认值为false） + # force_stream_mode = true # 强制流式输出模式（若模型不支持非流式输出，请取消该注释，启用强制流式输出，若无该字段，默认值为false） [[models]] model_identifier = "deepseek-ai/DeepSeek-V3.2-Exp" @@ -311,17 +325,48 @@ config: api_provider = "SiliconFlow" price_in = 2.0 price_out = 3.0 + # temperature = 0.5 # 可选：为该模型单独指定温度，会覆盖任务配置中的温度 + # max_tokens = 4096 # 可选：为该模型单独指定最大token数，会覆盖任务配置中的max_tokens [models.extra_params] # 可选的额外参数配置 enable_thinking = false # 不启用思考 + [[models]] model_identifier = "deepseek-ai/DeepSeek-V3.2-Exp" name = "siliconflow-deepseek-v3.2-think" api_provider = "SiliconFlow" price_in = 2.0 price_out = 3.0 + # temperature = 0.7 # 可选：为该模型单独指定温度，会覆盖任务配置中的温度 + # max_tokens = 4096 # 可选：为该模型单独指定最大token数，会覆盖任务配置中的max_tokens [models.extra_params] # 可选的额外参数配置 - enable_thinking = true # 不启用思考 + enable_thinking = true # 启用思考 + + + [[models]] + model_identifier = "Qwen/Qwen3-Next-80B-A3B-Instruct" + name = "qwen3-next-80b" + api_provider = "SiliconFlow" + price_in = 1.0 + price_out = 4.0 + + [[models]] + model_identifier = "zai-org/GLM-4.6" + name = "siliconflow-glm-4.6" + api_provider = "SiliconFlow" + price_in = 3.5 + price_out = 14.0 + [models.extra_params] # 可选的额外参数配置 + enable_thinking = false # 不启用思考 + + [[models]] + model_identifier = "zai-org/GLM-4.6" + name = "siliconflow-glm-4.6-think" + api_provider = "SiliconFlow" + price_in = 3.5 + price_out = 14.0 + [models.extra_params] # 可选的额外参数配置 + enable_thinking = true # 启用思考 [[models]] model_identifier = "deepseek-ai/DeepSeek-R1" @@ -364,64 +409,75 @@ config: [model_task_config.utils] # 在麦麦的一些组件中使用的模型，例如表情包模块，取名模块，关系模块，麦麦的情绪变化等，是麦麦必须的模型 model_list = ["siliconflow-deepseek-v3.2"] # 使用的模型列表，每个子项对应上面的模型名称(name) temperature = 0.2 # 模型温度，新V3建议0.1-0.3 - max_tokens = 2048 # 最大输出token数 + max_tokens = 4096 # 最大输出token数 + slow_threshold = 15.0 # 慢请求阈值（秒），模型等待回复时间超过此值会输出警告日志 [model_task_config.utils_small] # 在麦麦的一些组件中使用的小模型，消耗量较大，建议使用速度较快的小模型 model_list = ["qwen3-30b","qwen3-next-80b"] temperature = 0.7 max_tokens = 2048 + slow_threshold = 10.0 [model_task_config.tool_use] #工具调用模型，需要使用支持工具调用的模型 model_list = ["qwen3-30b","qwen3-next-80b"] temperature = 0.7 max_tokens = 800 + slow_threshold = 10.0 [model_task_config.replyer] # 首要回复模型，还用于表达器和表达方式学习 - model_list = ["siliconflow-deepseek-v3.2-think","siliconflow-glm-4.6-think","siliconflow-glm-4.6"] + model_list = ["siliconflow-deepseek-v3.2","siliconflow-deepseek-v3.2-think","siliconflow-glm-4.6","siliconflow-glm-4.6-think"] temperature = 0.3 # 模型温度，新V3建议0.1-0.3 max_tokens = 2048 + slow_threshold = 25.0 [model_task_config.planner] #决策：负责决定麦麦该什么时候回复的模型 model_list = ["siliconflow-deepseek-v3.2"] temperature = 0.3 max_tokens = 800 + slow_threshold = 12.0 [model_task_config.vlm] # 图像识别模型 model_list = ["qwen3-vl-30"] max_tokens = 256 + slow_threshold = 15.0 [model_task_config.voice] # 语音识别模型 model_list = ["sensevoice-small"] + slow_threshold = 12.0 - #嵌入模型 + # 嵌入模型 [model_task_config.embedding] model_list = ["bge-m3"] + slow_threshold = 5.0 - #------------LPMM知识库模型------------ + # ------------LPMM知识库模型------------ [model_task_config.lpmm_entity_extract] # 实体提取模型 model_list = ["siliconflow-deepseek-v3.2"] temperature = 0.2 max_tokens = 800 + slow_threshold = 20.0 [model_task_config.lpmm_rdf_build] # RDF构建模型 model_list = ["siliconflow-deepseek-v3.2"] temperature = 0.2 max_tokens = 800 + slow_threshold = 20.0 [model_task_config.lpmm_qa] # 问答模型 model_list = ["siliconflow-deepseek-v3.2"] temperature = 0.7 max_tokens = 800 + slow_threshold = 20.0 # core的bot_config.toml core_bot_config: | [inner] - version = "6.21.8" + version = "7.2.5" #----以下是给开发人员阅读的，如果你只是部署了麦麦，不需要阅读---- - #如果你想要修改配置文件，请递增version的值 - #如果新增项目，请阅读src/config/official_configs.py中的说明 + # 如果你想要修改配置文件，请递增version的值 + # 如果新增项目，请阅读src/config/official_configs.py中的说明 # # 版本格式：主版本号.次版本号.修订号，版本号递增规则如下： # 主版本号：MMC版本更新 @@ -440,21 +496,31 @@ config: [personality] # 建议120字以内，描述人格特质 和 身份特征 - personality = "是一个女大学生，现在在读大二，会刷贴吧。" - #アイデンティティがない 生まれないらららら - # 描述麦麦说话的表达风格，表达习惯，如要修改，可以酌情新增内容 - reply_style = "请回复的平淡一些，简短一些，说中文，不要刻意突出自身学科背景。可以参考贴吧，知乎和微博的回复风格。" + personality = "是一个大二在读女大学生，现在正在上网和群友聊天，有时有点攻击性，有时比较温柔" + # アイデンティティがない 生まれないらららら + # 描述麦麦说话的表达风格，表达习惯，如要修改，可以酌情新增内容，建议1-2行 + reply_style = "请不要刻意突出自身学科背景。可以参考贴吧，知乎和微博的回复风格。" - # 麦麦的兴趣，会影响麦麦对什么话题进行回复 - interest = "对技术相关话题，游戏和动漫相关话题感兴趣，也对日常话题感兴趣，不喜欢太过沉重严肃的话题" + # 多种回复风格列表，可选配置：当 non-empty 且 multiple_probability>0 时，会按概率随机从中选择一个替换 reply_style + multiple_reply_style = [ + # "你的风格平淡但不失讽刺，很简短,很白话。可以参考贴吧，微博的回复风格。", + # "用1-2个字进行回复", + # "用1-2个符号进行回复", + # "言辭凝練古雅，穿插《論語》經句卻不晦澀，以文言短句為基，輔以淺白語意，持長者溫和風範，全用繁體字表達，具先秦儒者談吐韻致。", + # "带点翻译腔，但不要太长", + ] + + # 替换概率：每次构建回复时，以该概率从 multiple_reply_style 中随机选择一个替换 reply_style（0.0-1.0） + multiple_probability = 0.3 # 麦麦的说话规则，行为风格: plan_style = """ 1.思考**所有**的可用的action中的**每个动作**是否符合当下条件，如果动作使用条件符合聊天内容就使用 2.如果相同的内容已经被执行，请不要重复执行 - 3.请控制你的发言频率，不要太过频繁的发言 - 4.如果有人对你感到厌烦，请减少回复 - 5.如果有人对你进行攻击，或者情绪激动，请你以合适的方法应对""" + 3.你对技术相关话题，游戏和动漫相关话题感兴趣，也对日常话题感兴趣，不喜欢太过沉重严肃的话题 + 4.请控制你的发言频率，不要太过频繁的发言 + 5.如果有人对你感到厌烦，请减少回复 + 6.如果有人在追问你，或者话题没有说完，请你继续回复""" # 麦麦识图规则，不建议修改 visual_style = "请用中文描述这张图片的内容。如果有文字，请把文字描述概括出来，请留意其主题，直观感受，输出为一段平文本，最多30字，请注意不要分点，就输出一段文本" @@ -475,18 +541,19 @@ config: # 替换概率，每次构建人格时替换personality的概率（0.0-1.0） state_probability = 0.3 + + [expression] # 表达学习配置 learning_list = [ # 表达学习配置列表，支持按聊天流配置 - ["", "enable", "enable", "1.0"], # 全局配置：使用表达，启用学习，学习强度1.0 - ["qq:1919810:group", "enable", "enable", "1.5"], # 特定群聊配置：使用表达，启用学习，学习强度1.5 - ["qq:114514:private", "enable", "disable", "0.5"], # 特定私聊配置：使用表达，禁用学习，学习强度0.5 + ["", "enable", "enable", "enable"], # 全局配置：使用表达，启用学习，启用jargon学习 + ["qq:1919810:group", "enable", "enable", "enable"], # 特定群聊配置：使用表达，启用学习，启用jargon学习 + ["qq:114514:private", "enable", "disable", "disable"], # 特定私聊配置：使用表达，禁用学习，禁用jargon学习 # 格式说明： # 第一位: chat_stream_id，空字符串表示全局配置 # 第二位: 是否使用学到的表达 ("enable"/"disable") # 第三位: 是否学习表达 ("enable"/"disable") - # 第四位: 学习强度（浮点数），影响学习频率，最短学习时间间隔 = 300/学习强度（秒） - # 学习强度越高，学习越频繁；学习强度越低，学习越少 + # 第四位: 是否启用jargon学习 ("enable"/"disable") ] expression_groups = [ @@ -498,12 +565,21 @@ config: # 注意：如果为群聊，则需要设置为group，如果设置为私聊，则需要设置为private ] + reflect = false # 是否启用表达反思（Bot主动向管理员询问表达方式是否合适） + reflect_operator_id = "" # 表达反思操作员ID，格式：platform:id:type (例如 "qq:123456:private" 或 "qq:654321:group") + allow_reflect = [] # 允许进行表达反思的聊天流ID列表，格式：["qq:123456:private", "qq:654321:group", ...]，只有在此列表中的聊天流才会提出问题并跟踪。如果列表为空，则所有聊天流都可以进行表达反思（前提是 reflect = true） - [chat] #麦麦的聊天设置 - talk_value = 1 #聊天频率，越小越沉默，范围0-1 + all_global_jargon = true # 是否开启全局黑话模式，注意，此功能关闭后，已经记录的全局黑话不会改变，需要手动删除 + enable_jargon_explanation = true # 是否在回复前尝试对上下文中的黑话进行解释（关闭可减少一次LLM调用，仅影响回复前的黑话匹配与解释，不影响黑话学习） + jargon_mode = "planner" # 黑话解释来源模式，可选： "context"（使用上下文自动匹配黑话） 或 "planner"（仅使用Planner在reply动作中给出的unknown_words列表） + + + [chat] # 麦麦的聊天设置 + talk_value = 1 # 聊天频率，越小越沉默，范围0-1 mentioned_bot_reply = true # 是否启用提及必回复 max_context_size = 30 # 上下文长度 - planner_smooth = 2 #规划器平滑，增大数值会减小planner负荷，略微降低反应速度，推荐1-5，0为关闭，必须大于等于0 + planner_smooth = 3 # 规划器平滑，增大数值会减小planner负荷，略微降低反应速度，推荐1-5，0为关闭，必须大于等于0 + think_mode = "dynamic" # 思考模式，可选：classic（默认浅度思考和回复）、deep（会进行比较长的，深度回复）、dynamic（动态选择两种模式） enable_talk_value_rules = true # 是否启用动态发言频率规则 @@ -511,7 +587,7 @@ config: # 推荐格式（对象数组）：{ 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。 + # - 支持跨夜区间，例如 "23:00-02:00"；数值范围建议 0-1，如果 value 设置为0会自动转换为0.0001以避免除以零错误。 talk_value_rules = [ { target = "", time = "00:00-08:59", value = 0.8 }, { target = "", time = "09:00-22:59", value = 1.0 }, @@ -519,22 +595,37 @@ config: { target = "qq:114514:private", time = "00:00-23:59", value = 0.3 }, ] - include_planner_reasoning = false # 是否将planner推理加入replyer，默认关闭（不加入） - [memory] - max_agent_iterations = 3 # 记忆思考深度（最低为1（不深入思考）） + max_agent_iterations = 3 # 记忆思考深度（最低为1） + agent_timeout_seconds = 45.0 # 最长回忆时间（秒） + enable_jargon_detection = true # 记忆检索过程中是否启用黑话识别 + global_memory = false # 是否允许记忆检索进行全局查询 - [jargon] - all_global = true # 是否开启全局黑话模式，注意，此功能关闭后，已经记录的全局黑话不会改变，需要手动删除 + [dream] + interval_minutes = 60 # 做梦时间间隔（分钟），默认30分钟 + max_iterations = 20 # 做梦最大轮次，默认20轮 + first_delay_seconds = 1800 # 程序启动后首次做梦前的延迟时间（秒），默认60秒 + + # 做梦结果推送目标，格式为 "platform:user_id" + # 例如: "qq:123456" 表示在做梦结束后，将梦境文本额外发送给该QQ私聊用户。 + # 为空字符串时不推送。 + dream_send = "" + + # 做梦时间段配置，格式：["HH:MM-HH:MM", ...] + # 如果列表为空，则表示全天允许做梦。 + # 如果配置了时间段，则只有在这些时间段内才会实际执行做梦流程。 + # 时间段外，调度器仍会按间隔检查，但不会进入做梦流程。 + # 支持跨夜区间，例如 "23:00-02:00" 表示从23:00到次日02:00。 + # 示例： + dream_time_ranges = [ + # "09:00-22:00", # 白天允许做梦 + "23:00-10:00", # 跨夜时间段（23:00到次日10:00） + ] + # dream_time_ranges = [] [tool] enable_tool = true # 是否启用工具 - [mood] - enable_mood = false # 是否启用情绪系统 - mood_update_threshold = 1 # 情绪更新阈值,越高，更新越慢 - # 情感特征，影响情绪的变化情况 - emotion_style = "情绪较为稳定，但遭遇特定事件的时候起伏较大" [emoji] emoji_chance = 0.4 # 麦麦激活表情包动作的概率 @@ -556,37 +647,38 @@ config: ban_msgs_regex = [ # 需要过滤的消息（原始消息）匹配的正则表达式，匹配到的消息将被过滤，若不了解正则表达式请勿修改 - #"https?://[^\\s]+", # 匹配https链接 - #"\\d{4}-\\d{2}-\\d{2}", # 匹配日期 + # "https?://[^\\s]+", # 匹配https链接 + # "\\d{4}-\\d{2}-\\d{2}", # 匹配日期 ] [lpmm_knowledge] # lpmm知识库配置 enable = false # 是否启用lpmm知识库 lpmm_mode = "agent" - # 可选：classic经典模式，agent 模式，结合最新的记忆一同使用 - rag_synonym_search_top_k = 10 # 同义词搜索TopK - rag_synonym_threshold = 0.8 # 同义词阈值（相似度高于此阈值的词语会被认为是同义词） - info_extraction_workers = 3 # 实体提取同时执行线程数，非Pro模型不要设置超过5 - qa_relation_search_top_k = 10 # 关系搜索TopK - qa_relation_threshold = 0.5 # 关系阈值（相似度高于此阈值的关系会被认为是相关的关系） - qa_paragraph_search_top_k = 1000 # 段落搜索TopK（不能过小，可能影响搜索结果） + # 可选择classic传统模式/agent 模式，结合新的记忆一同使用 + rag_synonym_search_top_k = 10 # 同义检索TopK + rag_synonym_threshold = 0.8 # 同义阈值，相似度高于该值的关系会被当作同义词 + info_extraction_workers = 3 # 实体抽取同时执行线程数，非Pro模型不要设置超过5 + qa_relation_search_top_k = 10 # 关系检索TopK + qa_relation_threshold = 0.5 # 关系阈值，相似度高于该值的关系会被认为是相关关系 + qa_paragraph_search_top_k = 1000 # 段落检索TopK（不能过小，可能影响搜索结果） qa_paragraph_node_weight = 0.05 # 段落节点权重（在图搜索&PPR计算中的权重，当搜索仅使用DPR时，此参数不起作用） qa_ent_filter_top_k = 10 # 实体过滤TopK qa_ppr_damping = 0.8 # PPR阻尼系数 - qa_res_top_k = 3 # 最终提供的文段TopK - embedding_dimension = 1024 # 嵌入向量维度,应该与模型的输出维度一致 + qa_res_top_k = 3 # 最终提供段落TopK + embedding_dimension = 1024 # 嵌入向量维度,输出维度一致 + # 性能与降级参数（低配机器可下调） + # 低配机器参考：单/双核或内存≤4GB（如轻量云主机/云函数/开发板），建议先关闭PPR并降低并发 + max_embedding_workers = 3 # 嵌入/抽取并发线程数 + embedding_chunk_size = 4 # 每批嵌入的条数 + max_synonym_entities = 2000 # 同义边参与的实体数上限，超限则跳过 + enable_ppr = true # 是否启用PPR，低配机器可关闭 - # keyword_rules 用于设置关键词触发的额外回复知识 - # 添加新规则方法：在 keyword_rules 数组中增加一项，格式如下： - # { keywords = ["关键词1", "关键词2"], reaction = "触发这些关键词时的回复内容" } - # 例如，添加一个新规则：当检测到“你好”或“hello”时回复“你好，有什么可以帮你？” - # { keywords = ["你好", "hello"], reaction = "你好，有什么可以帮你？" } [keyword_reaction] keyword_rules = [ { keywords = ["人机", "bot", "机器", "入机", "robot", "机器人", "ai", "AI"], reaction = "有人说你是人机或者机器人，否定这一事实，攻击或反问他。注意，只有认为你是机器人才回复，否则不要否认" }, { keywords = ["测试关键词回复", "test"], reaction = "回答测试成功" }, - #{ keywords = ["你好", "hello"], reaction = "你好，有什么可以帮你？" } + # { keywords = ["你好", "hello"], reaction = "你好，有什么可以帮你？" } # 在此处添加更多规则，格式同上 ] @@ -634,19 +726,35 @@ config: show_lpmm_paragraph = false # 是否显示lpmm找到的相关文段日志 [maim_message] - auth_token = [] # 认证令牌，用于API验证，为空则不启用验证 - # 以下项目若要使用需要打开use_custom，并单独配置maim_message的服务器 - use_custom = false # 是否启用自定义的maim_message服务器，注意这需要设置新的端口，不能与.env重复 - host="127.0.0.1" - port=8090 - mode="ws" # 支持ws和tcp两种模式 - use_wss = false # 是否使用WSS安全连接，只支持ws模式 - cert_file = "" # SSL证书文件路径，仅在use_wss=true时有效 - key_file = "" # SSL密钥文件路径，仅在use_wss=true时有效 + auth_token = [] # 认证令牌，用于旧版API验证，为空则不启用验证 + + # 新版API Server配置（额外监听端口） + enable_api_server = false # 是否启用额外的新版API Server + api_server_host = "0.0.0.0" # 新版API Server主机地址 + api_server_port = 8090 # 新版API Server端口号 + api_server_use_wss = false # 新版API Server是否启用WSS + api_server_cert_file = "" # 新版API Server SSL证书文件路径 + api_server_key_file = "" # 新版API Server SSL密钥文件路径 + api_server_allowed_api_keys = [] # 新版API Server允许的API Key列表，为空则允许所有连接 [telemetry] #发送统计信息，主要是看全球有多少只麦麦 enable = true + [webui] # WebUI 独立服务器配置 + # 注意: WebUI 的监听地址(host)和端口(port)已移至 .env 文件中的 WEBUI_HOST 和 WEBUI_PORT + enabled = true # 是否启用WebUI + mode = "production" # 模式: development(开发) 或 production(生产) + + # 防爬虫配置 + anti_crawler_mode = "basic" # 防爬虫模式: false(禁用) / strict(严格) / loose(宽松) / basic(基础-只记录不阻止) + allowed_ips = "127.0.0.1" # IP白名单（逗号分隔，支持精确IP、CIDR格式和通配符） + # 示例: 127.0.0.1,192.168.1.0/24,172.17.0.0/16 + trusted_proxies = "" # 信任的代理IP列表（逗号分隔），只有来自这些IP的X-Forwarded-For才被信任 + # 示例: 127.0.0.1,192.168.1.1,172.17.0.1 + trust_xff = false # 是否启用X-Forwarded-For代理解析（默认false） + # 启用后，仍要求直连IP在trusted_proxies中才会信任XFF头 + secure_cookie = false # 是否启用安全Cookie（仅通过HTTPS传输，默认false） + [experimental] #实验性功能 # 为指定聊天添加额外的prompt配置 # 格式: ["platform:id:type:prompt内容", ...] @@ -659,6 +767,6 @@ config: chat_prompts = [] - #此系统暂时移除，无效配置 + # 此系统暂时移除，无效配置 [relationship] enable_relationship = true # 是否启用关系系统 diff --git a/plugins/ChatFrequency/_manifest.json b/plugins/ChatFrequency/_manifest.json index 9a3a9632..669de6b8 100644 --- a/plugins/ChatFrequency/_manifest.json +++ b/plugins/ChatFrequency/_manifest.json @@ -8,18 +8,25 @@ "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"], - + "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", @@ -46,5 +53,6 @@ "支持完整命令和简化命令", "快速操作支持" ] - } + }, + "id": "SengokuCola.BetterFrequency" } \ No newline at end of file diff --git a/plugins/MaiBot_MCPBridgePlugin/.gitignore b/plugins/MaiBot_MCPBridgePlugin/.gitignore new file mode 100644 index 00000000..ebef83b0 --- /dev/null +++ b/plugins/MaiBot_MCPBridgePlugin/.gitignore @@ -0,0 +1,30 @@ +# 运行时配置（包含用户敏感信息） +config.toml + +# 备份文件 +*.backup.* +*.bak + +# 日志 +logs/ +*.log +*.jsonl + +# Python 缓存 +__pycache__/ +*.py[cod] +*$py.class +*.so + +# 本地测试脚本（仓库不提交） +test_*.py + +# IDE +.idea/ +.vscode/ +*.swp +*.swo + +# 系统文件 +.DS_Store +Thumbs.db diff --git a/plugins/MaiBot_MCPBridgePlugin/CHANGELOG.md b/plugins/MaiBot_MCPBridgePlugin/CHANGELOG.md new file mode 100644 index 00000000..0c3feb46 --- /dev/null +++ b/plugins/MaiBot_MCPBridgePlugin/CHANGELOG.md @@ -0,0 +1,24 @@ +# Changelog + +本文件记录 `MaiBot_MCPBridgePlugin` 的用户可感知变更。 + +## 2.0.0 + +- 配置入口统一：MCP 服务器仅使用 Claude Desktop `mcpServers` JSON（`servers.claude_config_json`） +- 兼容迁移：自动识别旧版 `servers.list` 并迁移为 `mcpServers`（需在 WebUI 保存一次固化） +- 保持功能不变：保留 Workflow（硬流程/工具链）与 ReAct（软流程）双轨制能力 +- 精简实现：移除旧的 WebUI 导入导出/快速添加服务器实现与 `tomlkit` 依赖 +- 易用性：完善 Workflow 变量替换（支持数组下标与 bracket 写法），并优化 WebUI 配置区顺序 + +## 1.9.0 + +- 双轨制架构：ReAct（软流程）+ Workflow（硬流程/工具链） + +## 1.8.0 + +- Workflow（工具链）：多工具顺序执行、变量替换、自定义 Workflow 并注册为组合工具 + +## 1.7.0 + +- 断路器模式、状态刷新、工具搜索等易用性增强 + diff --git a/plugins/MaiBot_MCPBridgePlugin/DEVELOPMENT.md b/plugins/MaiBot_MCPBridgePlugin/DEVELOPMENT.md new file mode 100644 index 00000000..7299fe13 --- /dev/null +++ b/plugins/MaiBot_MCPBridgePlugin/DEVELOPMENT.md @@ -0,0 +1,356 @@ +# MCP 桥接插件开发文档 + +本文档面向开发者，介绍插件的架构设计、核心模块和扩展方式。 + +## 架构概览 + +``` +MaiBot_MCPBridgePlugin/ +├── plugin.py # 主插件文件，包含所有核心逻辑 +├── mcp_client.py # MCP 客户端封装 +├── tool_chain.py # 工具链（Workflow）模块 +├── core/ +│ └── claude_config.py # Claude Desktop mcpServers 解析/迁移 +├── config.toml # 运行时配置 +└── _manifest.json # 插件元数据 +``` + +## 核心模块 + +### 1. MCP 客户端 (`mcp_client.py`) + +封装了与 MCP 服务器的通信逻辑。 + +```python +from .mcp_client import mcp_manager, MCPServerConfig, TransportType + +# 添加服务器 +config = MCPServerConfig( + name="my-server", + transport=TransportType.STREAMABLE_HTTP, + url="https://mcp.example.com/mcp" +) +await mcp_manager.add_server(config) + +# 调用工具 +result = await mcp_manager.call_tool("server_tool_name", {"param": "value"}) +if result.success: + print(result.content) +``` + +**支持的传输类型：** +- `STDIO`: 本地进程通信 +- `SSE`: Server-Sent Events +- `HTTP`: HTTP 请求 +- `STREAMABLE_HTTP`: 流式 HTTP（推荐） + +### 2. 工具注册系统 + +MCP 工具通过动态类创建注册到 MaiBot： + +```python +# 创建工具代理类 +class MCPToolProxy(BaseTool): + name = "mcp_server_tool" + description = "工具描述" + parameters = [("param", ToolParamType.STRING, "参数描述", True, None)] + available_for_llm = True + + async def execute(self, function_args): + result = await mcp_manager.call_tool(self._mcp_tool_key, function_args) + return {"name": self.name, "content": result.content} +``` + +### 3. 工具链模块 (`tool_chain.py`) + +实现 Workflow 硬流程，支持多工具顺序执行。 + +```python +from .tool_chain import ToolChainDefinition, ToolChainStep, tool_chain_manager + +# 定义工具链 +chain = ToolChainDefinition( + name="search_and_detail", + description="搜索并获取详情", + input_params={"query": "搜索关键词"}, + steps=[ + ToolChainStep( + tool_name="mcp_server_search", + args_template={"keyword": "${input.query}"}, + output_key="search_result" + ), + ToolChainStep( + tool_name="mcp_server_detail", + args_template={"id": "${prev}"} + ) + ] +) + +# 注册并执行 +tool_chain_manager.add_chain(chain) +result = await tool_chain_manager.execute_chain("search_and_detail", {"query": "test"}) +``` + +**变量替换语法：** +- `${input.参数名}`: 用户输入 +- `${step.输出键}`: 指定步骤的输出 +- `${prev}`: 上一步输出 +- `${prev.字段}`: 上一步输出（JSON）的字段 +- `${step.geo.return.0.location}` / `${step.geo.return[0].location}`: 数组下标访问 +- `${step.geo['return'][0]['location']}`: bracket 写法（最通用） + +## 双轨制架构 + +### ReAct 软流程 + +将 MCP 工具注册到 MaiBot 的记忆检索 ReAct 系统，LLM 自主决策调用。 + +```python +def _register_tools_to_react(self) -> int: + from src.memory_system.retrieval_tools import register_memory_retrieval_tool + + def make_execute_func(tool_key: str): + async def execute_func(**kwargs) -> str: + result = await mcp_manager.call_tool(tool_key, kwargs) + return result.content if result.success else f"失败: {result.error}" + return execute_func + + register_memory_retrieval_tool( + name="mcp_tool_name", + description="工具描述", + parameters=[{"name": "param", "type": "string", "required": True}], + execute_func=make_execute_func("tool_key") + ) +``` + +### Workflow 硬流程 + +用户预定义的固定执行流程，注册为组合工具。 + +```python +def _register_tool_chains(self) -> None: + from src.plugin_system.core.component_registry import component_registry + + for chain_name, chain in tool_chain_manager.get_enabled_chains().items(): + info, tool_class = tool_chain_registry.register_chain(chain) + info.plugin_name = self.plugin_name + component_registry.register_component(info, tool_class) +``` + +## 配置系统 + +### MCP 服务器配置（Claude Desktop 规范） + +插件只接受 Claude Desktop 的 `mcpServers` JSON（见 `core/claude_config.py`）。配置入口统一为： + +- WebUI/配置文件：`[servers].claude_config_json` +- 命令：`/mcp import`（合并 `mcpServers`）与 `/mcp export`（导出当前 `mcpServers`） + +兼容迁移： +- 若检测到旧版 `servers.list`，会自动迁移为 `servers.claude_config_json`（仅迁移到内存配置，需 WebUI 保存一次固化）。 + +### WebUI 配置 Schema + +使用 `ConfigField` 定义 WebUI 配置项： + +```python +config_schema = { + "section_name": { + "field_name": ConfigField( + type=str, # 类型: str, bool, int, float + default="default_value", # 默认值 + description="字段描述", + label="显示标签", + input_type="textarea", # 输入类型: text, textarea, password + rows=5, # textarea 行数 + disabled=True, # 只读 + choices=["a", "b"], # 下拉选项 + hint="提示信息", + order=1, # 排序 + ), + }, +} +``` + +### 配置读取 + +```python +# 在组件中读取配置 +value = self.get_config("section.key", default="fallback") + +# 在插件类中读取 +value = self.config.get("section", {}).get("key", "default") +``` + +## 事件处理 + +### 启动事件 + +```python +class MCPStartupHandler(BaseEventHandler): + event_type = EventType.ON_START + handler_name = "mcp_startup" + + async def execute(self, message): + global _plugin_instance + if _plugin_instance: + await _plugin_instance._async_connect_servers() + return (True, True, None, None, None) +``` + +### 停止事件 + +```python +class MCPStopHandler(BaseEventHandler): + event_type = EventType.ON_STOP + handler_name = "mcp_stop" + + async def execute(self, message): + await mcp_manager.shutdown() + return (True, True, None, None, None) +``` + +## 命令系统 + +```python +class MCPStatusCommand(BaseCommand): + command_name = "mcp_status" + command_pattern = r"^/mcp(?:\s+(?P\S+))?(?:\s+(?P.+))?$" + + async def execute(self) -> Tuple[bool, str, bool]: + action = self.matched_groups.get("action", "") + arg = self.matched_groups.get("arg", "") + + if action == "tools": + await self.send_text("工具列表...") + elif action == "reconnect": + await self._handle_reconnect(arg) + + return (True, None, True) # (成功, 消息, 拦截) +``` + +## 高级功能 + +### 调用追踪 + +```python +from plugin import tool_call_tracer, ToolCallRecord + +# 记录调用 +record = ToolCallRecord( + call_id="xxx", + timestamp=time.time(), + tool_name="tool", + server_name="server", + arguments={"key": "value"}, + success=True, + duration_ms=100.0 +) +tool_call_tracer.record(record) + +# 查询记录 +recent = tool_call_tracer.get_recent(10) +by_tool = tool_call_tracer.get_by_tool("tool_name") +``` + +### 调用缓存 + +```python +from plugin import tool_call_cache + +# 配置缓存 +tool_call_cache.configure( + enabled=True, + ttl=300, # 秒 + max_entries=200, + exclude_tools="mcp_*_time_*" # 排除模式 +) + +# 使用缓存 +cached = tool_call_cache.get("tool_name", {"param": "value"}) +if cached is None: + result = await call_tool(...) + tool_call_cache.set("tool_name", {"param": "value"}, result) +``` + +### 权限控制 + +```python +from plugin import permission_checker + +# 配置权限 +permission_checker.configure( + enabled=True, + default_mode="allow_all", # 或 "deny_all" + rules_json='[{"tool": "mcp_*_delete_*", "denied": ["qq:123:group"]}]', + quick_deny_groups="123456789", + quick_allow_users="111111111" +) + +# 检查权限 +allowed = permission_checker.check( + tool_name="mcp_server_delete", + chat_id="123456", + user_id="789", + is_group=True +) +``` + +### 断路器模式 + +MCP 客户端内置断路器，故障服务器快速失败： + +- 连续失败 N 次后熔断 +- 熔断期间直接返回错误 +- 定期尝试恢复 + +## 扩展开发 + +### 添加新的传输类型 + +1. 在 `mcp_client.py` 中添加 `TransportType` 枚举值 +2. 实现对应的连接逻辑 +3. 更新 `_create_transport()` 方法 + +### 添加新的工具类型 + +1. 继承 `BaseTool` 创建新类 +2. 在 `get_plugin_components()` 中注册 +3. 实现 `execute()` 方法 + +### 添加新的命令 + +1. 在 `MCPStatusCommand.execute()` 中添加新的 action 分支 +2. 或创建新的 `BaseCommand` 子类 + +## 调试技巧 + +### 日志级别 + +```python +from src.common.logger import get_logger +logger = get_logger("mcp_bridge_plugin") + +logger.debug("详细调试信息") +logger.info("一般信息") +logger.warning("警告") +logger.error("错误") +``` + +### 常用调试命令 + +```bash +/mcp # 查看状态 +/mcp tools # 查看工具列表 +/mcp trace # 查看调用记录 +/mcp cache # 查看缓存状态 +/mcp chain # 查看工具链 +``` + +## 更新日志 + +见 `plugins/MaiBot_MCPBridgePlugin/CHANGELOG.md` + +## 开发约定 + +- 本仓库不提交测试脚本/临时复现文件；如需本地验证，可自行在工作区创建未跟踪文件（建议放到 `.local/` 并加入 `.gitignore`）。 diff --git a/plugins/MaiBot_MCPBridgePlugin/README.md b/plugins/MaiBot_MCPBridgePlugin/README.md new file mode 100644 index 00000000..61aca8f5 --- /dev/null +++ b/plugins/MaiBot_MCPBridgePlugin/README.md @@ -0,0 +1,357 @@ +# MCP 桥接插件 + +将 [MCP (Model Context Protocol)](https://modelcontextprotocol.io/) 服务器的工具桥接到 MaiBot，使麦麦能够调用外部 MCP 工具。 + +image + +## 🚀 快速开始 + +### 1. 安装 + +```bash +# 克隆到 MaiBot 插件目录 +cd /path/to/MaiBot/plugins +git clone https://github.com/CharTyr/MaiBot_MCPBridgePlugin.git MCPBridgePlugin + +# 安装依赖 +pip install mcp + +# 复制配置文件 +cd MCPBridgePlugin +cp config.example.toml config.toml +``` + +### 2. 添加服务器 + +编辑 `config.toml`，在 `[servers]` 的 `claude_config_json` 中填写 Claude Desktop 的 `mcpServers` JSON： + +```toml +[servers] +claude_config_json = ''' +{ + "mcpServers": { + "time": { "transport": "streamable_http", "url": "https://mcp.api-inference.modelscope.cn/server/mcp-server-time" }, + "my-server": { "transport": "streamable_http", "url": "https://mcp.xxx.com/mcp", "headers": { "Authorization": "Bearer 你的密钥" } }, + "fetch": { "command": "uvx", "args": ["mcp-server-fetch"] } + } +} +''' +``` + +### 3. 启动 + +重启 MaiBot，或发送 `/mcp reconnect` + +--- + +## 📚 去哪找 MCP 服务器？ + +| 平台 | 说明 | +|------|------| +| [mcp.modelscope.cn](https://mcp.modelscope.cn/) | 魔搭 ModelScope，免费推荐 | +| [smithery.ai](https://smithery.ai/) | MCP 服务器注册中心 | +| [github.com/modelcontextprotocol/servers](https://github.com/modelcontextprotocol/servers) | 官方服务器列表 | + +--- + +## 💡 常用命令 + +| 命令 | 说明 | +|------|------| +| `/mcp` | 查看连接状态 | +| `/mcp tools` | 查看可用工具 | +| `/mcp reconnect` | 重连服务器 | +| `/mcp trace` | 查看调用记录 | +| `/mcp cache` | 查看缓存状态 | +| `/mcp perm` | 查看权限配置 | +| `/mcp import ` | 🆕 导入 Claude Desktop 配置 | +| `/mcp export` | 🆕 导出配置 | +| `/mcp search <关键词>` | 🆕 搜索工具 | +| `/mcp chain` | 🆕 查看工具链 | +| `/mcp chain <名称>` | 🆕 查看工具链详情 | +| `/mcp chain test <名称> <参数>` | 🆕 测试执行工具链 | + +--- + +## ✨ 功能特性 + +### 核心功能 +- 🔌 多服务器同时连接 +- 📡 支持 stdio / SSE / HTTP / Streamable HTTP +- 🔄 自动重试、心跳检测、断线重连 +- 🖥️ WebUI 完整配置支持 + +### 双轨制架构 +- 🔄 **ReAct（软流程）**：LLM 自主决策，多轮动态调用 MCP 工具（适合探索式场景） +- 🔗 **Workflow（硬流程/工具链）**：用户预定义步骤顺序与参数传递（适合可控可复用场景） + +### 高级功能 +- 📦 Resources 支持（实验性） +- 📝 Prompts 支持（实验性） +- 🔄 结果后处理（LLM 摘要提炼） +- 🔍 调用追踪 / 🗄️ 调用缓存 / 🔐 权限控制 / 🚫 工具禁用 + +### 更新日志 +- 见 `plugins/MaiBot_MCPBridgePlugin/CHANGELOG.md` + +--- + +## ⚙️ 配置说明 + +### 服务器配置 + +```json +{ + "mcpServers": { + "server_name": { + "transport": "streamable_http", + "url": "https://..." + } + } +} +``` + +| 字段 | 说明 | +|------|------| +| `mcpServers.` | 服务器名称（唯一） | +| `enabled` | 是否启用（可选，默认 true） | +| `transport` | `stdio` / `sse` / `http` / `streamable_http` | +| `url` | 远程服务器地址 | +| `headers` | 🆕 鉴权头（如 `{"Authorization": "Bearer xxx"}`） | +| `command` / `args` | 本地服务器启动命令 | + +### 权限控制 + +**快捷配置（推荐）：** +```toml +[permissions] +perm_enabled = true +quick_deny_groups = "123456789" # 禁用的群号 +quick_allow_users = "111111111" # 管理员白名单 +``` + +**高级规则：** +```json +[{"tool": "mcp_*_delete_*", "denied": ["qq:123456:group"]}] +``` + +### 工具禁用 + +```toml +[tools] +disabled_tools = ''' +mcp_filesystem_delete_file +mcp_filesystem_write_file +''' +``` + +### 调用缓存 + +```toml +[settings] +cache_enabled = true +cache_ttl = 300 +cache_exclude_tools = "mcp_*_time_*" +``` + +--- + +## ❓ 常见问题 + +**Q: 工具没有注册？** +- 检查 `enabled = true` +- 检查 MaiBot 日志错误信息 +- 确认 `pip install mcp` + +**Q: JSON 格式报错？** +- 多行 JSON 用 `'''` 三引号包裹 +- 使用英文双引号 `"` + +**Q: 如何手动重连？** +- `/mcp reconnect` 或 `/mcp reconnect 服务器名` + +--- + +## 📥 配置导入导出（Claude mcpServers） + +### 从 Claude Desktop 导入 + +如果你已有 Claude Desktop 的 MCP 配置，可以直接导入： + +``` +/mcp import {"mcpServers":{"time":{"command":"uvx","args":["mcp-server-time"]},"fetch":{"command":"uvx","args":["mcp-server-fetch"]}}} +``` + +支持的格式： +- Claude Desktop 格式（`mcpServers` 对象） +- 兼容旧版：MaiBot servers 列表数组（将自动迁移为 `mcpServers`） + +### 导出配置 + +``` +/mcp export # 导出为 Claude Desktop 格式（默认） +/mcp export claude # 导出为 Claude Desktop 格式 +``` + +### 注意事项 +- 导入时会自动跳过同名服务器 +- 导入后需要发送 `/mcp reconnect` 使配置生效 +- 支持 stdio、sse、http、streamable_http 全部传输类型 + +--- + +## 🔗 Workflow（硬流程/工具链） + +工具链允许你将多个 MCP 工具按顺序执行，后续工具可以使用前序工具的输出作为输入。 + +### 1 分钟上手（推荐 WebUI） +1. 先完成 MCP 服务器配置并 `/mcp reconnect` +2. 发送 `/mcp tools`，复制你要用的工具名 +3. 打开 WebUI → 「Workflow（硬流程/工具链）」→ 用“快速添加”表单填入： + - 名称/描述 + - 输入参数（每行 `参数名=描述`） + - 执行步骤（每行 `工具名|参数JSON|输出键`） +4. 在“确认添加”中输入 `ADD` 并保存 + +### 快速添加工具链（推荐） + +在 WebUI 的「工具链」配置区，使用表单快速添加： + +1. **名称**: 填写工具链名称（英文，如 `search_and_detail`） +2. **描述**: 填写工具链用途（供 LLM 理解何时使用） +3. **输入参数**: 每行一个，格式 `参数名=描述` + ``` + query=搜索关键词 + max_results=最大结果数 + ``` +4. **执行步骤**: 每行一个，格式 `工具名|参数JSON|输出键` + ``` + mcp_server_search|{"keyword":"${input.query}"}|search_result + mcp_server_detail|{"id":"${prev}"}| + ``` +5. **确认添加**: 输入 `ADD` 并保存 + +### JSON 配置方式 + +也可以直接在「工具链列表」中编写 JSON： + +```json +[ + { + "name": "search_and_detail", + "description": "先搜索模组，再获取详情", + "input_params": { + "query": "搜索关键词" + }, + "steps": [ + { + "tool_name": "mcp_mcmod_search_mod", + "args_template": {"keyword": "${input.query}", "limit": 1}, + "output_key": "search_result", + "description": "搜索模组" + }, + { + "tool_name": "mcp_mcmod_get_mod_detail", + "args_template": {"mod_id": "${prev}"}, + "description": "获取详情" + } + ] + } +] +``` + +### 变量替换 + +| 变量格式 | 说明 | +|---------|------| +| `${input.参数名}` | 用户输入的参数 | +| `${step.输出键}` | 某个步骤的输出（通过 `output_key` 指定） | +| `${prev}` | 上一步的输出 | +| `${prev.字段}` | 上一步输出（JSON）的某个字段 | +| `${step.geo.return.0.location}` | 数组下标访问（dot） | +| `${step.geo.return[0].location}` | 数组下标访问（[]） | +| `${step.geo['return'][0]['location']}` | bracket 写法（最通用） | + +### 工具链字段说明 + +| 字段 | 说明 | +|------|------| +| `name` | 工具链名称，将生成 `chain_xxx` 工具 | +| `description` | 描述，供 LLM 理解何时使用 | +| `input_params` | 输入参数定义 `{参数名: 描述}` | +| `steps` | 执行步骤数组 | +| `steps[].tool_name` | 要调用的工具名 | +| `steps[].args_template` | 参数模板，支持变量替换 | +| `steps[].output_key` | 输出存储键名（可选） | +| `steps[].optional` | 是否可选，失败时继续执行（默认 false） | + +### 命令 + +```bash +/mcp chain # 查看所有工具链 +/mcp chain list # 列出工具链 +/mcp chain <名称> # 查看详情 +/mcp chain test <名称> {"query": "JEI"} # 测试执行 +/mcp chain reload # 重新加载配置 +``` + +--- + +## 🔄 双轨制架构 + +MCP 桥接插件支持两种工具调用模式，可根据场景选择： + +### ReAct 软流程 + +LLM 自主决策的多轮工具调用模式，适合复杂、不确定的场景。 + +**工作原理：** +1. 用户提问 → LLM 分析需要什么信息 +2. LLM 选择调用工具 → 获取结果 +3. LLM 观察结果 → 决定是否需要更多信息 +4. 重复 2-3 直到信息足够 → 生成最终回答 + +**启用方式：** +在 WebUI「ReAct (软流程)」配置区启用，MCP 工具将自动注册到 MaiBot 的记忆检索 ReAct 系统。 + +**适用场景：** +- 复杂问题需要多步推理 +- 不确定需要调用哪些工具 +- 需要根据中间结果动态调整 + +### Workflow 硬流程 + +用户预定义的工作流，固定执行顺序，适合可靠、可控的场景。 + +**工作原理：** +1. 用户定义步骤顺序和参数传递 +2. 按顺序执行每个步骤 +3. 后续步骤可使用前序步骤的输出 +4. 返回最终结果 + +**适用场景：** +- 流程固定、可预测 +- 需要可靠、可重复的执行 +- 希望精确控制工具调用顺序 + +### 对比 + +| 特性 | ReAct 软流程 | Workflow 硬流程 | +|------|-------------|----------------| +| 决策者 | LLM 自主决策 | 用户预定义 | +| 灵活性 | 高，动态调整 | 低，固定流程 | +| 可预测性 | 低 | 高 | +| 适用场景 | 复杂、探索性任务 | 固定、重复性任务 | +| 配置方式 | 启用即可 | 需要定义步骤 | + +--- + +## 📋 依赖 + +- MaiBot >= 0.11.6 +- Python >= 3.10 +- mcp >= 1.0.0 + +## 📄 许可证 + +AGPL-3.0 diff --git a/plugins/MaiBot_MCPBridgePlugin/__init__.py b/plugins/MaiBot_MCPBridgePlugin/__init__.py new file mode 100644 index 00000000..80e2ae47 --- /dev/null +++ b/plugins/MaiBot_MCPBridgePlugin/__init__.py @@ -0,0 +1,44 @@ +""" +MCP 桥接插件 +将 MCP (Model Context Protocol) 服务器的工具桥接到 MaiBot + +v1.1.0 新增功能: +- 心跳检测和自动重连 +- 调用统计（次数、成功率、耗时） +- 更好的错误处理 + +v1.2.0 新增功能: +- Resources 支持（资源读取） +- Prompts 支持（提示模板） +""" + +from .plugin import MCPBridgePlugin, mcp_tool_registry, MCPStartupHandler, MCPStopHandler +from .mcp_client import ( + mcp_manager, + MCPClientManager, + MCPServerConfig, + TransportType, + MCPCallResult, + MCPToolInfo, + MCPResourceInfo, + MCPPromptInfo, + ToolCallStats, + ServerStats, +) + +__all__ = [ + "MCPBridgePlugin", + "mcp_tool_registry", + "mcp_manager", + "MCPClientManager", + "MCPServerConfig", + "TransportType", + "MCPCallResult", + "MCPToolInfo", + "MCPResourceInfo", + "MCPPromptInfo", + "ToolCallStats", + "ServerStats", + "MCPStartupHandler", + "MCPStopHandler", +] diff --git a/plugins/MaiBot_MCPBridgePlugin/_manifest.json b/plugins/MaiBot_MCPBridgePlugin/_manifest.json new file mode 100644 index 00000000..85225a43 --- /dev/null +++ b/plugins/MaiBot_MCPBridgePlugin/_manifest.json @@ -0,0 +1,67 @@ +{ + "manifest_version": 1, + "name": "MCP桥接插件", + "version": "2.0.0", + "description": "将 MCP (Model Context Protocol) 服务器的工具桥接到 MaiBot，使麦麦能够调用外部 MCP 工具", + "author": { + "name": "CharTyr", + "url": "https://github.com/CharTyr" + }, + "license": "AGPL-3.0", + "host_application": { + "min_version": "0.11.6" + }, + "homepage_url": "https://github.com/CharTyr/MaiBot_MCPBridgePlugin", + "repository_url": "https://github.com/CharTyr/MaiBot_MCPBridgePlugin", + "keywords": [ + "mcp", + "bridge", + "tool", + "integration", + "resources", + "prompts", + "post-process", + "cache", + "trace", + "permissions", + "import", + "export", + "claude-desktop", + "workflow", + "react", + "agent" + ], + "categories": [ + "工具扩展", + "外部集成" + ], + "default_locale": "zh-CN", + "plugin_info": { + "is_built_in": false, + "components": [], + "features": [ + "支持多个 MCP 服务器", + "自动发现并注册 MCP 工具", + "支持 stdio、SSE、HTTP、Streamable HTTP 四种传输方式", + "工具参数自动转换", + "心跳检测与自动重连", + "调用统计（次数、成功率、耗时）", + "WebUI 配置支持", + "Resources 支持（实验性）", + "Prompts 支持（实验性）", + "结果后处理（LLM 摘要提炼）", + "工具禁用管理", + "调用链路追踪", + "工具调用缓存（LRU）", + "工具权限控制（群/用户级别）", + "配置导入导出（Claude Desktop mcpServers）", + "断路器模式（故障快速失败）", + "状态实时刷新", + "Workflow 硬流程（顺序执行多个工具）", + "Workflow 快速添加（表单式配置）", + "ReAct 软流程（LLM 自主多轮调用）", + "双轨制架构（软流程 + 硬流程）" + ] + }, + "id": "MaiBot Community.MCPBridgePlugin" +} diff --git a/plugins/MaiBot_MCPBridgePlugin/config.example.toml b/plugins/MaiBot_MCPBridgePlugin/config.example.toml new file mode 100644 index 00000000..4edac27a --- /dev/null +++ b/plugins/MaiBot_MCPBridgePlugin/config.example.toml @@ -0,0 +1,309 @@ +# MCP桥接插件 - 配置文件示例 +# 将 MCP (Model Context Protocol) 服务器的工具桥接到 MaiBot +# +# 使用方法：复制此文件为 config.toml，然后根据需要修改配置 +# +# ============================================================ +# 🎯 快速开始（三步） +# ============================================================ +# 1. 在下方 [servers] 添加 MCP 服务器配置 +# 2. 将 enabled 改为 true 启用服务器 +# 3. 重启 MaiBot 或发送 /mcp reconnect +# +# ============================================================ +# 📚 去哪找 MCP 服务器？ +# ============================================================ +# +# 【远程服务（推荐新手）】 +# - ModelScope: https://mcp.modelscope.cn/ (免费，推荐) +# - Smithery: https://smithery.ai/ +# - Glama: https://glama.ai/mcp/servers +# +# 【本地服务（需要 npx 或 uvx）】 +# - 官方列表: https://github.com/modelcontextprotocol/servers +# +# ============================================================ + +# ============================================================ +# 🔌 MCP 服务器配置 +# ============================================================ +# +# ⚠️ 重要：配置格式（Claude Desktop 规范） +# ──────────────────────────────────────────────────────────── +# 统一使用 Claude Desktop 的 mcpServers JSON。 +# +# claude_config_json 的内容应为 JSON 对象： +# { +# "mcpServers": { +# "server_name": { ...server config... }, +# "another": { ... } +# } +# } +# +# 每个服务器支持字段： +# transport - 传输方式: "stdio" / "sse" / "http" / "streamable_http"（可选） +# url - 服务器地址（sse/http/streamable_http 模式） +# command - 启动命令（stdio 模式，如 "npx" / "uvx"） +# args - 命令参数数组（stdio 模式） +# env - 环境变量对象（stdio 模式，可选） +# headers - 鉴权头（可选，如 {"Authorization": "Bearer xxx"}） +# enabled - 是否启用（可选，默认 true） +# post_process - 服务器级别后处理配置（可选） +# +# ============================================================ + +[servers] +claude_config_json = ''' +{ + "mcpServers": { + "time-mcp-server": { + "enabled": false, + "transport": "streamable_http", + "url": "https://mcp.api-inference.modelscope.cn/server/mcp-server-time" + }, + "my-auth-server": { + "enabled": false, + "transport": "streamable_http", + "url": "https://mcp.api-inference.modelscope.net/xxxxxx/mcp", + "headers": { + "Authorization": "Bearer ms-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + } + }, + "fetch-local": { + "enabled": false, + "command": "uvx", + "args": ["mcp-server-fetch"] + } + } +} +''' + +# ============================================================ +# 插件基本信息 +# ============================================================ +[plugin] +name = "mcp_bridge_plugin" +version = "2.0.0" +config_version = "2.0.0" +enabled = false # 默认禁用，在 WebUI 中启用 + +# ============================================================ +# Workflow（硬流程/工具链） +# ============================================================ +# +# 作用：把多个工具按顺序执行；后续步骤可引用前序输出。 +# +# ✅ 推荐配置方式：WebUI「Workflow（硬流程/工具链）」里用“快速添加”表单。 +# ✅ 也可以直接写 chains_list（JSON 数组）。 +# +# 变量替换： +# ${input.xxx} - 用户输入 +# ${step.} - 指定步骤输出（需设置 output_key） +# ${prev} - 上一步输出 +# ${prev.字段} - 上一步输出（JSON）的字段 +# ${step.geo.return.0.location} - 数组/下标访问（dot） +# ${step.geo.return[0].location} - 数组/下标访问（[]） +# ${step.geo['return'][0]['location']} - bracket 写法 +# +# ============================================================ + +[tool_chains] +chains_enabled = true + +chains_list = ''' +[ + { + "name": "search_and_detail", + "description": "先搜索，再根据结果获取详情", + "input_params": { "query": "搜索关键词" }, + "steps": [ + { "tool_name": "把这里替换成你的搜索工具名", "args_template": { "keyword": "${input.query}" }, "output_key": "search" }, + { "tool_name": "把这里替换成你的详情工具名", "args_template": { "id": "${prev}" } } + ] + } +] +''' + +# ============================================================ +# ReAct（软流程） +# ============================================================ +# +# 作用：把 MCP 工具注册到 MaiBot 的 ReAct 系统，LLM 可自主多轮调用。 +# +# 注意：ReAct 适合“探索式/不确定”场景；Workflow 适合“固定/可控”场景。 +# +# ============================================================ + +[react] +react_enabled = false +filter_mode = "whitelist" # whitelist / blacklist +tool_filter = "" # 每行一个工具名，支持通配符 * + +# ============================================================ +# 全局设置（高级设置建议保持默认） +# ============================================================ +[settings] +# 🏷️ 工具前缀 - 用于区分 MCP 工具和原生工具 +tool_prefix = "mcp" + +# ⏱️ 连接超时（秒） +connect_timeout = 30.0 + +# ⏱️ 调用超时（秒） +call_timeout = 60.0 + +# 🔄 自动连接 - 启动时自动连接所有已启用的服务器 +auto_connect = true + +# 🔁 重试次数 - 连接失败时的重试次数 +retry_attempts = 3 + +# ⏳ 重试间隔（秒） +retry_interval = 5.0 + +# 💓 心跳检测 - 定期检测服务器连接状态 +heartbeat_enabled = true + +# 💓 心跳间隔（秒）- 建议 30-120 秒 +heartbeat_interval = 60.0 + +# 🔄 自动重连 - 检测到断开时自动尝试重连 +auto_reconnect = true + +# 🔄 最大重连次数 - 连续重连失败后暂停重连 +max_reconnect_attempts = 3 + +# ============================================================ +# 高级功能（实验性） +# ============================================================ +# 📦 启用 Resources - 允许读取 MCP 服务器提供的资源 +enable_resources = false + +# 📝 启用 Prompts - 允许使用 MCP 服务器提供的提示模板 +enable_prompts = false + +# ============================================================ +# 结果后处理功能 +# ============================================================ +# 当 MCP 工具返回的内容过长时，使用 LLM 对结果进行摘要提炼 + +# 🔄 启用结果后处理 +post_process_enabled = false + +# 📏 后处理阈值（字符数）- 结果长度超过此值才触发后处理 +post_process_threshold = 500 + +# 🔢 后处理输出限制 - LLM 摘要输出的最大 token 数 +post_process_max_tokens = 500 + +# 🤖 后处理模型（可选）- 留空则使用 utils 模型组 +post_process_model = "" + +# 🧠 后处理提示词模板 +post_process_prompt = '''用户问题：{query} + +工具返回内容： +{result} + +请从上述内容中提取与用户问题最相关的关键信息，简洁准确地输出：''' + +# ============================================================ +# 调用链路追踪 +# ============================================================ +# 记录工具调用详情，便于调试和分析 + +# 🔍 启用调用追踪 +trace_enabled = true + +# 📊 追踪记录上限 - 内存中保留的最大记录数 +trace_max_records = 50 + +# 📝 追踪日志文件 - 是否将追踪记录写入日志文件 +# 启用后记录写入 plugins/MaiBot_MCPBridgePlugin/logs/trace.jsonl +trace_log_enabled = false + +# ============================================================ +# 工具调用缓存 +# ============================================================ +# 缓存相同参数的调用结果，减少重复请求 + +# 🗄️ 启用调用缓存 +cache_enabled = false + +# ⏱️ 缓存有效期（秒） +cache_ttl = 300 + +# 📦 最大缓存条目 - 超出后 LRU 淘汰 +cache_max_entries = 200 + +# 🚫 缓存排除列表 - 即不缓存的工具（每行一个，支持通配符 *） +# 时间类、随机类工具建议排除 +cache_exclude_tools = ''' +mcp_*_time_* +mcp_*_random_* +''' + +# ============================================================ +# 工具管理 +# ============================================================ +[tools] +# 📋 工具清单（只读）- 启动后自动生成 +tool_list = "(启动后自动生成)" + +# 🚫 禁用工具列表 - 要禁用的工具名（每行一个） +# 从上方工具清单复制工具名，禁用后该工具不会被 LLM 调用 +# 示例： +# disabled_tools = ''' +# mcp_filesystem_delete_file +# mcp_filesystem_write_file +# ''' +disabled_tools = "" + +# ============================================================ +# 权限控制 +# ============================================================ +[permissions] +# 🔐 启用权限控制 - 按群/用户限制工具使用 +perm_enabled = false + +# 📋 默认模式 +# allow_all: 未配置规则的工具默认允许 +# deny_all: 未配置规则的工具默认禁止 +perm_default_mode = "allow_all" + +# ──────────────────────────────────────────────────────────── +# 🚀 快捷配置（推荐新手使用） +# ──────────────────────────────────────────────────────────── + +# 🚫 禁用群列表 - 这些群无法使用任何 MCP 工具（每行一个群号） +# 示例： +# quick_deny_groups = ''' +# 123456789 +# 987654321 +# ''' +quick_deny_groups = "" + +# ✅ 管理员白名单 - 这些用户始终可以使用所有工具（每行一个QQ号） +# 示例： +# quick_allow_users = ''' +# 111111111 +# ''' +quick_allow_users = "" + +# ──────────────────────────────────────────────────────────── +# 📜 高级权限规则（可选，针对特定工具配置） +# ──────────────────────────────────────────────────────────── +# 格式: qq:ID:group/private/user，工具名支持通配符 * +# 示例： +# perm_rules = ''' +# [ +# {"tool": "mcp_*_delete_*", "denied": ["qq:123456:group"]} +# ] +# ''' +perm_rules = "[]" + +# ============================================================ +# 状态显示（只读） +# ============================================================ +[status] +connection_status = "未初始化" diff --git a/plugins/MaiBot_MCPBridgePlugin/core/__init__.py b/plugins/MaiBot_MCPBridgePlugin/core/__init__.py new file mode 100644 index 00000000..8e85539f --- /dev/null +++ b/plugins/MaiBot_MCPBridgePlugin/core/__init__.py @@ -0,0 +1,2 @@ +"""Core helpers for MCP Bridge Plugin.""" + diff --git a/plugins/MaiBot_MCPBridgePlugin/core/claude_config.py b/plugins/MaiBot_MCPBridgePlugin/core/claude_config.py new file mode 100644 index 00000000..6ae5ff97 --- /dev/null +++ b/plugins/MaiBot_MCPBridgePlugin/core/claude_config.py @@ -0,0 +1,170 @@ +import json +from dataclasses import dataclass, field +from typing import Any, Dict, List, Literal, Optional + + +class ClaudeConfigError(ValueError): + pass + + +Transport = Literal["stdio", "sse", "http", "streamable_http"] + + +@dataclass(frozen=True) +class ClaudeMcpServer: + name: str + transport: Transport + command: str = "" + args: List[str] = field(default_factory=list) + env: Dict[str, str] = field(default_factory=dict) + url: str = "" + headers: Dict[str, str] = field(default_factory=dict) + enabled: bool = True + + +def _normalize_transport(value: Optional[str]) -> Transport: + if not value: + return "streamable_http" + v = value.strip().lower().replace("-", "_") + if v in ("streamable_http", "streamablehttp", "streamable"): + return "streamable_http" + if v in ("http",): + return "http" + if v in ("sse",): + return "sse" + if v in ("stdio",): + return "stdio" + raise ClaudeConfigError(f"unsupported transport: {value}") + + +def _coerce_str_list(value: Any, field_name: str) -> List[str]: + if value is None: + return [] + if isinstance(value, list): + return [str(v) for v in value] + raise ClaudeConfigError(f"{field_name} must be a list") + + +def _coerce_str_dict(value: Any, field_name: str) -> Dict[str, str]: + if value is None: + return {} + if isinstance(value, dict): + return {str(k): str(v) for k, v in value.items()} + raise ClaudeConfigError(f"{field_name} must be an object") + + +def parse_claude_mcp_config(config_json: str) -> List[ClaudeMcpServer]: + """Parse Claude Desktop style MCP config JSON. + + Supported: + - Full object: {"mcpServers": {...}} + - Direct mapping: {...} treated as mcpServers + """ + text = (config_json or "").strip() + if not text: + return [] + + try: + data = json.loads(text) + except json.JSONDecodeError as e: + raise ClaudeConfigError(f"invalid JSON: {e}") from e + + if not isinstance(data, dict): + raise ClaudeConfigError("config must be a JSON object") + + servers_obj = data.get("mcpServers", data) + if not isinstance(servers_obj, dict): + raise ClaudeConfigError("mcpServers must be an object") + + servers: List[ClaudeMcpServer] = [] + for name, raw in servers_obj.items(): + if not isinstance(name, str) or not name.strip(): + raise ClaudeConfigError("server name must be a non-empty string") + if not isinstance(raw, dict): + raise ClaudeConfigError(f"server '{name}' must be an object") + + enabled = bool(raw.get("enabled", True)) + command = str(raw.get("command", "") or "") + url = str(raw.get("url", "") or "") + args = _coerce_str_list(raw.get("args"), "args") + env = _coerce_str_dict(raw.get("env"), "env") + headers = _coerce_str_dict(raw.get("headers"), "headers") + + transport_hint = raw.get("transport", raw.get("type")) + + if command: + transport: Transport = "stdio" + elif url: + try: + transport = _normalize_transport(str(transport_hint) if transport_hint is not None else None) + except ClaudeConfigError: + transport = "streamable_http" + else: + raise ClaudeConfigError(f"server '{name}' must have either 'command' or 'url'") + + servers.append( + ClaudeMcpServer( + name=name, + transport=transport, + command=command, + args=args, + env=env, + url=url, + headers=headers, + enabled=enabled, + ) + ) + + return servers + + +def legacy_servers_list_to_claude_config(servers_list_json: str) -> str: + """Convert legacy v1.x servers list (JSON array) to Claude mcpServers JSON. + + Legacy item schema: + {"name","enabled","transport","url","headers","command","args","env"} + """ + text = (servers_list_json or "").strip() + if not text: + return "" + try: + data = json.loads(text) + except json.JSONDecodeError: + return "" + if isinstance(data, dict): + data = [data] + if not isinstance(data, list): + return "" + + mcp_servers: Dict[str, Any] = {} + for item in data: + if not isinstance(item, dict): + continue + name = str(item.get("name", "") or "").strip() + if not name: + continue + enabled = bool(item.get("enabled", True)) + transport = str(item.get("transport", "") or "").strip().lower().replace("-", "_") + + if transport == "stdio" or item.get("command"): + entry: Dict[str, Any] = { + "enabled": enabled, + "command": item.get("command", "") or "", + "args": item.get("args", []) or [], + } + if item.get("env"): + entry["env"] = item.get("env") + mcp_servers[name] = entry + continue + + entry = {"enabled": enabled, "url": item.get("url", "") or ""} + if item.get("headers"): + entry["headers"] = item.get("headers") + if transport: + entry["transport"] = transport + mcp_servers[name] = entry + + if not mcp_servers: + return "" + return json.dumps({"mcpServers": mcp_servers}, ensure_ascii=False, indent=2) + diff --git a/plugins/MaiBot_MCPBridgePlugin/mcp_client.py b/plugins/MaiBot_MCPBridgePlugin/mcp_client.py new file mode 100644 index 00000000..0d4eebff --- /dev/null +++ b/plugins/MaiBot_MCPBridgePlugin/mcp_client.py @@ -0,0 +1,1542 @@ +""" +MCP 客户端封装模块 +负责与 MCP 服务器建立连接、获取工具列表、执行工具调用 + +v1.7.0 稳定性优化: +- 断路器模式：连续失败 5 次后熔断，60 秒后试探恢复 +- 熔断期间快速失败，避免等待超时 +- 连接成功时自动重置断路器 + +v1.5.2 性能优化: +- 智能心跳间隔：根据服务器稳定性动态调整心跳频率 +- 稳定服务器逐渐增加间隔（最高 3x），减少不必要的检测 +- 断开的服务器使用较短间隔快速重连 + +v1.1.0 新增功能: +- 调用统计（次数、成功率、耗时） +- 心跳检测 +- 自动重连 +- 更好的错误处理 + +v1.2.0 新增功能: +- Resources 支持（资源读取） +- Prompts 支持（提示模板） +- 新增配置项: enable_resources, enable_prompts +""" + +import asyncio +import time +import logging +from typing import Any, Dict, List, Optional, Tuple +from dataclasses import dataclass, field +from enum import Enum + +# 尝试导入 MaiBot 的 logger，如果失败则使用标准 logging +try: + from src.common.logger import get_logger + logger = get_logger("mcp_client") +except ImportError: + # Fallback: 使用标准 logging + logger = logging.getLogger("mcp_client") + if not logger.handlers: + handler = logging.StreamHandler() + handler.setFormatter(logging.Formatter('[%(levelname)s] %(name)s: %(message)s')) + logger.addHandler(handler) + logger.setLevel(logging.INFO) + + +class TransportType(Enum): + """MCP 传输类型""" + STDIO = "stdio" # 本地进程通信 + SSE = "sse" # Server-Sent Events (旧版 HTTP) + HTTP = "http" # HTTP Streamable (新版，推荐) + STREAMABLE_HTTP = "streamable_http" # HTTP Streamable 的别名 + + +@dataclass +class MCPToolInfo: + """MCP 工具信息""" + name: str + description: str + input_schema: Dict[str, Any] + server_name: str + + +@dataclass +class MCPResourceInfo: + """MCP 资源信息""" + uri: str + name: str + description: str + mime_type: Optional[str] + server_name: str + + +@dataclass +class MCPPromptInfo: + """MCP 提示模板信息""" + name: str + description: str + arguments: List[Dict[str, Any]] # [{name, description, required}] + server_name: str + + +@dataclass +class MCPServerConfig: + """MCP 服务器配置""" + name: str + enabled: bool = True + transport: TransportType = TransportType.STDIO + # stdio 配置 + command: str = "" + args: List[str] = field(default_factory=list) + env: Dict[str, str] = field(default_factory=dict) + # http/sse 配置 + url: str = "" + headers: Dict[str, str] = field(default_factory=dict) # v1.4.2: 鉴权头支持 + + +@dataclass +class MCPCallResult: + """MCP 工具调用结果""" + success: bool + content: Any + error: Optional[str] = None + duration_ms: float = 0.0 # 调用耗时（毫秒） + circuit_broken: bool = False # v1.7.0: 是否被断路器拦截 + + +class CircuitState(Enum): + """断路器状态""" + CLOSED = "closed" # 正常状态，允许请求 + OPEN = "open" # 熔断状态，拒绝请求 + HALF_OPEN = "half_open" # 半开状态，允许少量试探请求 + + +@dataclass +class CircuitBreaker: + """v1.7.0: 断路器 - 防止对故障服务器持续请求 + + 状态转换: + - CLOSED -> OPEN: 连续失败次数达到阈值 + - OPEN -> HALF_OPEN: 熔断时间到期 + - HALF_OPEN -> CLOSED: 试探请求成功 + - HALF_OPEN -> OPEN: 试探请求失败 + """ + + # 配置 + failure_threshold: int = 5 # 连续失败多少次后熔断 + recovery_timeout: float = 60.0 # 熔断后多久尝试恢复（秒） + half_open_max_calls: int = 1 # 半开状态最多允许几次试探调用 + + # 状态 + state: CircuitState = field(default=CircuitState.CLOSED) + failure_count: int = 0 + success_count: int = 0 + last_failure_time: float = 0.0 + last_state_change: float = field(default_factory=time.time) + half_open_calls: int = 0 + + def can_execute(self) -> Tuple[bool, Optional[str]]: + """检查是否允许执行请求 + + Returns: + (是否允许, 拒绝原因) + """ + current_time = time.time() + + if self.state == CircuitState.CLOSED: + return True, None + + if self.state == CircuitState.OPEN: + # 检查是否到了恢复时间 + time_since_failure = current_time - self.last_failure_time + if time_since_failure >= self.recovery_timeout: + # 转换到半开状态 + self._transition_to(CircuitState.HALF_OPEN) + return True, None + else: + remaining = self.recovery_timeout - time_since_failure + return False, f"断路器熔断中，{remaining:.0f}秒后重试" + + if self.state == CircuitState.HALF_OPEN: + # 半开状态，检查是否还有试探配额 + if self.half_open_calls < self.half_open_max_calls: + return True, None + else: + return False, "断路器半开状态，等待试探结果" + + return True, None + + def record_success(self) -> None: + """记录成功调用""" + self.success_count += 1 + + if self.state == CircuitState.HALF_OPEN: + # 半开状态下成功，恢复到关闭状态 + self._transition_to(CircuitState.CLOSED) + logger.info("断路器恢复正常（试探成功）") + elif self.state == CircuitState.CLOSED: + # 正常状态下成功，重置失败计数 + self.failure_count = 0 + + def record_failure(self) -> None: + """记录失败调用""" + self.failure_count += 1 + self.last_failure_time = time.time() + + if self.state == CircuitState.HALF_OPEN: + # 半开状态下失败，重新熔断 + self._transition_to(CircuitState.OPEN) + logger.warning("断路器重新熔断（试探失败）") + elif self.state == CircuitState.CLOSED: + # 检查是否达到熔断阈值 + if self.failure_count >= self.failure_threshold: + self._transition_to(CircuitState.OPEN) + logger.warning(f"断路器熔断（连续失败 {self.failure_count} 次）") + + def _transition_to(self, new_state: CircuitState) -> None: + """状态转换""" + old_state = self.state + self.state = new_state + self.last_state_change = time.time() + + if new_state == CircuitState.CLOSED: + self.failure_count = 0 + self.half_open_calls = 0 + elif new_state == CircuitState.HALF_OPEN: + self.half_open_calls = 0 + + logger.debug(f"断路器状态: {old_state.value} -> {new_state.value}") + + def reset(self) -> None: + """重置断路器""" + self.state = CircuitState.CLOSED + self.failure_count = 0 + self.success_count = 0 + self.half_open_calls = 0 + self.last_state_change = time.time() + + def get_status(self) -> Dict[str, Any]: + """获取断路器状态""" + return { + "state": self.state.value, + "failure_count": self.failure_count, + "success_count": self.success_count, + "failure_threshold": self.failure_threshold, + "recovery_timeout": self.recovery_timeout, + "time_since_last_failure": time.time() - self.last_failure_time if self.last_failure_time > 0 else None, + } + + +@dataclass +class ToolCallStats: + """工具调用统计""" + tool_key: str + total_calls: int = 0 + success_calls: int = 0 + failed_calls: int = 0 + total_duration_ms: float = 0.0 + last_call_time: Optional[float] = None + last_error: Optional[str] = None + + @property + def success_rate(self) -> float: + """成功率（0-100）""" + if self.total_calls == 0: + return 0.0 + return (self.success_calls / self.total_calls) * 100 + + @property + def avg_duration_ms(self) -> float: + """平均耗时（毫秒）""" + if self.success_calls == 0: + return 0.0 + return self.total_duration_ms / self.success_calls + + def record_call(self, success: bool, duration_ms: float, error: Optional[str] = None) -> None: + """记录一次调用""" + self.total_calls += 1 + self.last_call_time = time.time() + if success: + self.success_calls += 1 + self.total_duration_ms += duration_ms + else: + self.failed_calls += 1 + self.last_error = error + + def to_dict(self) -> Dict[str, Any]: + """转换为字典""" + return { + "tool_key": self.tool_key, + "total_calls": self.total_calls, + "success_calls": self.success_calls, + "failed_calls": self.failed_calls, + "success_rate": round(self.success_rate, 2), + "avg_duration_ms": round(self.avg_duration_ms, 2), + "last_call_time": self.last_call_time, + "last_error": self.last_error, + } + + +@dataclass +class ServerStats: + """服务器统计""" + server_name: str + connect_count: int = 0 # 连接次数 + disconnect_count: int = 0 # 断开次数 + reconnect_count: int = 0 # 重连次数 + last_connect_time: Optional[float] = None + last_disconnect_time: Optional[float] = None + last_heartbeat_time: Optional[float] = None + consecutive_failures: int = 0 # 连续失败次数 + + def record_connect(self) -> None: + self.connect_count += 1 + self.last_connect_time = time.time() + self.consecutive_failures = 0 + + def record_disconnect(self) -> None: + self.disconnect_count += 1 + self.last_disconnect_time = time.time() + + def record_reconnect(self) -> None: + self.reconnect_count += 1 + self.consecutive_failures = 0 + + def record_failure(self) -> None: + self.consecutive_failures += 1 + + def record_heartbeat(self) -> None: + self.last_heartbeat_time = time.time() + + def to_dict(self) -> Dict[str, Any]: + return { + "server_name": self.server_name, + "connect_count": self.connect_count, + "disconnect_count": self.disconnect_count, + "reconnect_count": self.reconnect_count, + "last_connect_time": self.last_connect_time, + "last_disconnect_time": self.last_disconnect_time, + "last_heartbeat_time": self.last_heartbeat_time, + "consecutive_failures": self.consecutive_failures, + } + + +class MCPClientSession: + """MCP 客户端会话，管理与单个 MCP 服务器的连接""" + + def __init__(self, config: MCPServerConfig, call_timeout: float = 60.0): + self.config = config + self.call_timeout = call_timeout + self._session = None + self._read_stream = None + self._write_stream = None + self._process: Optional[asyncio.subprocess.Process] = None + self._tools: List[MCPToolInfo] = [] + self._resources: List[MCPResourceInfo] = [] # v1.2.0: Resources 支持 + self._prompts: List[MCPPromptInfo] = [] # v1.2.0: Prompts 支持 + self._connected = False + self._lock = asyncio.Lock() + + # 功能支持标记（服务器可能不支持某些功能） + self._supports_resources: bool = False + self._supports_prompts: bool = False + + # 统计信息 + self.stats = ServerStats(server_name=config.name) + self._tool_stats: Dict[str, ToolCallStats] = {} + + # v1.7.0: 断路器 + self._circuit_breaker = CircuitBreaker() + + @property + def is_connected(self) -> bool: + return self._connected + + @property + def tools(self) -> List[MCPToolInfo]: + return self._tools.copy() + + @property + def resources(self) -> List[MCPResourceInfo]: + """v1.2.0: 获取资源列表""" + return self._resources.copy() + + @property + def prompts(self) -> List[MCPPromptInfo]: + """v1.2.0: 获取提示模板列表""" + return self._prompts.copy() + + @property + def supports_resources(self) -> bool: + """v1.2.0: 服务器是否支持 Resources""" + return self._supports_resources + + @property + def supports_prompts(self) -> bool: + """v1.2.0: 服务器是否支持 Prompts""" + return self._supports_prompts + + @property + def server_name(self) -> str: + return self.config.name + + def get_tool_stats(self, tool_name: str) -> Optional[ToolCallStats]: + """获取工具统计""" + return self._tool_stats.get(tool_name) + + def get_circuit_breaker_status(self) -> Dict[str, Any]: + """v1.7.0: 获取断路器状态""" + return self._circuit_breaker.get_status() + + def reset_circuit_breaker(self) -> None: + """v1.7.0: 重置断路器""" + self._circuit_breaker.reset() + logger.info(f"[{self.server_name}] 断路器已重置") + + def get_all_tool_stats(self) -> Dict[str, ToolCallStats]: + """获取所有工具统计""" + return self._tool_stats.copy() + + async def connect(self) -> bool: + """连接到 MCP 服务器""" + async with self._lock: + if self._connected: + return True + + try: + success = False + if self.config.transport == TransportType.STDIO: + success = await self._connect_stdio() + elif self.config.transport == TransportType.SSE: + success = await self._connect_sse() + elif self.config.transport in (TransportType.HTTP, TransportType.STREAMABLE_HTTP): + success = await self._connect_http() + else: + logger.error(f"[{self.server_name}] 不支持的传输类型: {self.config.transport}") + return False + + if success: + self.stats.record_connect() + # v1.7.0: 连接成功时重置断路器 + self._circuit_breaker.reset() + else: + self.stats.record_failure() + return success + + except Exception as e: + logger.error(f"[{self.server_name}] 连接失败: {e}") + self._connected = False + self.stats.record_failure() + return False + + async def _connect_stdio(self) -> bool: + """通过 stdio 连接 MCP 服务器""" + try: + try: + from mcp import ClientSession, StdioServerParameters + from mcp.client.stdio import stdio_client + except ImportError: + logger.error(f"[{self.server_name}] 未安装 mcp 库，请运行: pip install mcp") + return False + + server_params = StdioServerParameters( + command=self.config.command, + args=self.config.args, + env=self.config.env if self.config.env else None + ) + + self._stdio_context = stdio_client(server_params) + self._read_stream, self._write_stream = await self._stdio_context.__aenter__() + + self._session_context = ClientSession(self._read_stream, self._write_stream) + self._session = await self._session_context.__aenter__() + + await self._session.initialize() + await self._fetch_tools() + + self._connected = True + logger.info(f"[{self.server_name}] stdio 连接成功，发现 {len(self._tools)} 个工具") + return True + + except Exception as e: + logger.error(f"[{self.server_name}] stdio 连接失败: {e}") + await self._cleanup() + return False + + async def _connect_sse(self) -> bool: + """通过 SSE 连接 MCP 服务器""" + try: + try: + from mcp import ClientSession + from mcp.client.sse import sse_client + except ImportError: + logger.error(f"[{self.server_name}] 未安装 mcp 库，请运行: pip install mcp") + return False + + if not self.config.url: + logger.error(f"[{self.server_name}] SSE 传输需要配置 url") + return False + + logger.debug(f"[{self.server_name}] 正在连接 SSE MCP 服务器: {self.config.url}") + + # v1.4.2: 支持 headers 鉴权 + sse_kwargs = { + "url": self.config.url, + "timeout": 60.0, + "sse_read_timeout": 300.0, + } + if self.config.headers: + sse_kwargs["headers"] = self.config.headers + + self._sse_context = sse_client(**sse_kwargs) + self._read_stream, self._write_stream = await self._sse_context.__aenter__() + + self._session_context = ClientSession(self._read_stream, self._write_stream) + self._session = await self._session_context.__aenter__() + + await self._session.initialize() + await self._fetch_tools() + + self._connected = True + logger.info(f"[{self.server_name}] SSE 连接成功，发现 {len(self._tools)} 个工具") + return True + + except Exception as e: + logger.error(f"[{self.server_name}] SSE 连接失败: {e}") + import traceback + logger.debug(f"[{self.server_name}] 详细错误: {traceback.format_exc()}") + await self._cleanup() + return False + + async def _connect_http(self) -> bool: + """通过 HTTP Streamable 连接 MCP 服务器""" + try: + try: + from mcp import ClientSession + from mcp.client.streamable_http import streamablehttp_client + except ImportError: + logger.error(f"[{self.server_name}] 未安装 mcp 库，请运行: pip install mcp") + return False + + if not self.config.url: + logger.error(f"[{self.server_name}] HTTP 传输需要配置 url") + return False + + logger.debug(f"[{self.server_name}] 正在连接 HTTP MCP 服务器: {self.config.url}") + + # v1.4.2: 支持 headers 鉴权 + http_kwargs = { + "url": self.config.url, + "timeout": 60.0, + "sse_read_timeout": 300.0, + } + if self.config.headers: + http_kwargs["headers"] = self.config.headers + + self._http_context = streamablehttp_client(**http_kwargs) + self._read_stream, self._write_stream, self._get_session_id = await self._http_context.__aenter__() + + self._session_context = ClientSession(self._read_stream, self._write_stream) + self._session = await self._session_context.__aenter__() + + await self._session.initialize() + await self._fetch_tools() + + self._connected = True + logger.info(f"[{self.server_name}] HTTP 连接成功，发现 {len(self._tools)} 个工具") + return True + + except Exception as e: + logger.error(f"[{self.server_name}] HTTP 连接失败: {e}") + import traceback + logger.debug(f"[{self.server_name}] 详细错误: {traceback.format_exc()}") + await self._cleanup() + return False + + async def _fetch_tools(self) -> None: + """获取 MCP 服务器的工具列表""" + if not self._session: + return + + try: + result = await self._session.list_tools() + self._tools = [] + + for tool in result.tools: + tool_info = MCPToolInfo( + name=tool.name, + description=tool.description or f"MCP tool: {tool.name}", + input_schema=tool.inputSchema if hasattr(tool, 'inputSchema') else {}, + server_name=self.server_name + ) + self._tools.append(tool_info) + # 初始化工具统计 + if tool.name not in self._tool_stats: + self._tool_stats[tool.name] = ToolCallStats(tool_key=tool.name) + logger.debug(f"[{self.server_name}] 发现工具: {tool.name}") + + except Exception as e: + logger.error(f"[{self.server_name}] 获取工具列表失败: {e}") + self._tools = [] + + async def fetch_resources(self) -> bool: + """v1.2.0: 获取 MCP 服务器的资源列表 + + Returns: + bool: 是否成功获取（服务器不支持时返回 False） + """ + if not self._session: + return False + + try: + result = await asyncio.wait_for( + self._session.list_resources(), + timeout=self.call_timeout + ) + self._resources = [] + + for resource in result.resources: + resource_info = MCPResourceInfo( + uri=str(resource.uri), + name=resource.name or str(resource.uri), + description=resource.description or "", + mime_type=resource.mimeType if hasattr(resource, 'mimeType') else None, + server_name=self.server_name + ) + self._resources.append(resource_info) + logger.debug(f"[{self.server_name}] 发现资源: {resource_info.uri}") + + self._supports_resources = True + logger.info(f"[{self.server_name}] 获取到 {len(self._resources)} 个资源") + return True + + except Exception as e: + # 服务器可能不支持 resources，这不是错误 + error_str = str(e).lower() + if "not supported" in error_str or "not implemented" in error_str or "method not found" in error_str: + logger.debug(f"[{self.server_name}] 服务器不支持 Resources 功能") + else: + logger.warning(f"[{self.server_name}] 获取资源列表失败: {e}") + self._supports_resources = False + self._resources = [] + return False + + async def fetch_prompts(self) -> bool: + """v1.2.0: 获取 MCP 服务器的提示模板列表 + + Returns: + bool: 是否成功获取（服务器不支持时返回 False） + """ + if not self._session: + return False + + try: + result = await asyncio.wait_for( + self._session.list_prompts(), + timeout=self.call_timeout + ) + self._prompts = [] + + for prompt in result.prompts: + # 解析参数 + arguments = [] + if hasattr(prompt, 'arguments') and prompt.arguments: + for arg in prompt.arguments: + arguments.append({ + "name": arg.name, + "description": arg.description or "", + "required": arg.required if hasattr(arg, 'required') else False, + }) + + prompt_info = MCPPromptInfo( + name=prompt.name, + description=prompt.description or f"MCP prompt: {prompt.name}", + arguments=arguments, + server_name=self.server_name + ) + self._prompts.append(prompt_info) + logger.debug(f"[{self.server_name}] 发现提示模板: {prompt.name}") + + self._supports_prompts = True + logger.info(f"[{self.server_name}] 获取到 {len(self._prompts)} 个提示模板") + return True + + except Exception as e: + # 服务器可能不支持 prompts，这不是错误 + error_str = str(e).lower() + if "not supported" in error_str or "not implemented" in error_str or "method not found" in error_str: + logger.debug(f"[{self.server_name}] 服务器不支持 Prompts 功能") + else: + logger.warning(f"[{self.server_name}] 获取提示模板列表失败: {e}") + self._supports_prompts = False + self._prompts = [] + return False + + async def read_resource(self, uri: str) -> MCPCallResult: + """v1.2.0: 读取指定资源的内容 + + Args: + uri: 资源 URI + + Returns: + MCPCallResult: 包含资源内容的结果 + """ + start_time = time.time() + + if not self._connected or not self._session: + return MCPCallResult( + success=False, + content=None, + error=f"服务器 {self.server_name} 未连接" + ) + + if not self._supports_resources: + return MCPCallResult( + success=False, + content=None, + error=f"服务器 {self.server_name} 不支持 Resources 功能" + ) + + try: + result = await asyncio.wait_for( + self._session.read_resource(uri), + timeout=self.call_timeout + ) + + duration_ms = (time.time() - start_time) * 1000 + + # 处理返回内容 + content_parts = [] + for content in result.contents: + if hasattr(content, 'text'): + content_parts.append(content.text) + elif hasattr(content, 'blob'): + # 二进制数据，返回 base64 或提示 + import base64 + blob_data = content.blob + if len(blob_data) < 10000: # 小于 10KB 返回 base64 + content_parts.append(f"[base64]{base64.b64encode(blob_data).decode()}") + else: + content_parts.append(f"[二进制数据: {len(blob_data)} bytes]") + else: + content_parts.append(str(content)) + + return MCPCallResult( + success=True, + content="\n".join(content_parts) if content_parts else "", + duration_ms=duration_ms + ) + + except asyncio.TimeoutError: + duration_ms = (time.time() - start_time) * 1000 + return MCPCallResult( + success=False, + content=None, + error=f"读取资源超时（{self.call_timeout}秒）", + duration_ms=duration_ms + ) + except Exception as e: + duration_ms = (time.time() - start_time) * 1000 + logger.error(f"[{self.server_name}] 读取资源 {uri} 失败: {e}") + return MCPCallResult( + success=False, + content=None, + error=str(e), + duration_ms=duration_ms + ) + + async def get_prompt(self, name: str, arguments: Optional[Dict[str, str]] = None) -> MCPCallResult: + """v1.2.0: 获取提示模板的内容 + + Args: + name: 提示模板名称 + arguments: 模板参数 + + Returns: + MCPCallResult: 包含提示内容的结果 + """ + start_time = time.time() + + if not self._connected or not self._session: + return MCPCallResult( + success=False, + content=None, + error=f"服务器 {self.server_name} 未连接" + ) + + if not self._supports_prompts: + return MCPCallResult( + success=False, + content=None, + error=f"服务器 {self.server_name} 不支持 Prompts 功能" + ) + + try: + result = await asyncio.wait_for( + self._session.get_prompt(name, arguments=arguments or {}), + timeout=self.call_timeout + ) + + duration_ms = (time.time() - start_time) * 1000 + + # 处理返回的消息 + messages = [] + for msg in result.messages: + role = msg.role if hasattr(msg, 'role') else "unknown" + content_text = "" + if hasattr(msg, 'content'): + if hasattr(msg.content, 'text'): + content_text = msg.content.text + elif isinstance(msg.content, str): + content_text = msg.content + else: + content_text = str(msg.content) + messages.append(f"[{role}]: {content_text}") + + return MCPCallResult( + success=True, + content="\n\n".join(messages) if messages else "", + duration_ms=duration_ms + ) + + except asyncio.TimeoutError: + duration_ms = (time.time() - start_time) * 1000 + return MCPCallResult( + success=False, + content=None, + error=f"获取提示模板超时（{self.call_timeout}秒）", + duration_ms=duration_ms + ) + except Exception as e: + duration_ms = (time.time() - start_time) * 1000 + logger.error(f"[{self.server_name}] 获取提示模板 {name} 失败: {e}") + return MCPCallResult( + success=False, + content=None, + error=str(e), + duration_ms=duration_ms + ) + + async def check_health(self) -> bool: + """检查连接健康状态（心跳检测） + + 通过调用 list_tools 来验证连接是否正常 + """ + if not self._connected or not self._session: + return False + + try: + # 使用 list_tools 作为心跳检测 + await asyncio.wait_for( + self._session.list_tools(), + timeout=10.0 + ) + self.stats.record_heartbeat() + return True + except Exception as e: + logger.warning(f"[{self.server_name}] 心跳检测失败: {e}") + # 标记为断开 + self._connected = False + self.stats.record_disconnect() + return False + + async def call_tool(self, tool_name: str, arguments: Dict[str, Any]) -> MCPCallResult: + """调用 MCP 工具""" + start_time = time.time() + + # v1.7.0: 断路器检查 + can_execute, reject_reason = self._circuit_breaker.can_execute() + if not can_execute: + return MCPCallResult( + success=False, + content=None, + error=f"⚡ {reject_reason}", + circuit_broken=True + ) + + # 半开状态下增加试探计数 + if self._circuit_breaker.state == CircuitState.HALF_OPEN: + self._circuit_breaker.half_open_calls += 1 + + if not self._connected or not self._session: + error_msg = f"服务器 {self.server_name} 未连接" + # 记录失败 + if tool_name in self._tool_stats: + self._tool_stats[tool_name].record_call(False, 0, error_msg) + self._circuit_breaker.record_failure() + return MCPCallResult(success=False, content=None, error=error_msg) + + try: + result = await asyncio.wait_for( + self._session.call_tool(tool_name, arguments=arguments), + timeout=self.call_timeout + ) + + duration_ms = (time.time() - start_time) * 1000 + + # 处理返回内容 + content_parts = [] + for content in result.content: + if hasattr(content, 'text'): + content_parts.append(content.text) + elif hasattr(content, 'data'): + content_parts.append(f"[二进制数据: {len(content.data)} bytes]") + else: + content_parts.append(str(content)) + + # 记录成功 + if tool_name in self._tool_stats: + self._tool_stats[tool_name].record_call(True, duration_ms) + + # v1.7.0: 断路器记录成功 + self._circuit_breaker.record_success() + + return MCPCallResult( + success=True, + content="\n".join(content_parts) if content_parts else "执行成功（无返回内容）", + duration_ms=duration_ms + ) + + except asyncio.TimeoutError: + duration_ms = (time.time() - start_time) * 1000 + error_msg = f"工具调用超时（{self.call_timeout}秒）" + if tool_name in self._tool_stats: + self._tool_stats[tool_name].record_call(False, duration_ms, error_msg) + # v1.7.0: 断路器记录失败 + self._circuit_breaker.record_failure() + return MCPCallResult(success=False, content=None, error=error_msg, duration_ms=duration_ms) + + except Exception as e: + duration_ms = (time.time() - start_time) * 1000 + error_msg = str(e) + logger.error(f"[{self.server_name}] 调用工具 {tool_name} 失败: {e}") + if tool_name in self._tool_stats: + self._tool_stats[tool_name].record_call(False, duration_ms, error_msg) + # v1.7.0: 断路器记录失败 + self._circuit_breaker.record_failure() + # 检查是否是连接问题 + if "connection" in error_msg.lower() or "closed" in error_msg.lower(): + self._connected = False + self.stats.record_disconnect() + return MCPCallResult(success=False, content=None, error=error_msg, duration_ms=duration_ms) + + async def disconnect(self) -> None: + """断开连接""" + async with self._lock: + if self._connected: + self.stats.record_disconnect() + await self._cleanup() + + async def _cleanup(self) -> None: + """清理资源""" + self._connected = False + self._tools = [] + self._resources = [] # v1.2.0 + self._prompts = [] # v1.2.0 + self._supports_resources = False # v1.2.0 + self._supports_prompts = False # v1.2.0 + + try: + if hasattr(self, '_session_context') and self._session_context: + await self._session_context.__aexit__(None, None, None) + except Exception as e: + logger.debug(f"[{self.server_name}] 关闭会话时出错: {e}") + + try: + if hasattr(self, '_stdio_context') and self._stdio_context: + await self._stdio_context.__aexit__(None, None, None) + except Exception as e: + logger.debug(f"[{self.server_name}] 关闭 stdio 连接时出错: {e}") + + try: + if hasattr(self, '_http_context') and self._http_context: + await self._http_context.__aexit__(None, None, None) + except Exception as e: + logger.debug(f"[{self.server_name}] 关闭 HTTP 连接时出错: {e}") + + try: + if hasattr(self, '_sse_context') and self._sse_context: + await self._sse_context.__aexit__(None, None, None) + except Exception as e: + logger.debug(f"[{self.server_name}] 关闭 SSE 连接时出错: {e}") + + self._session = None + self._session_context = None + self._stdio_context = None + self._http_context = None + self._sse_context = None + self._read_stream = None + self._write_stream = None + + logger.debug(f"[{self.server_name}] 连接已关闭") + + +class MCPClientManager: + """MCP 客户端管理器，管理多个 MCP 服务器连接 + + 功能: + - 管理多个 MCP 服务器连接 + - 心跳检测和自动重连 + - 调用统计 + """ + + _instance: Optional["MCPClientManager"] = None + + def __new__(cls): + if cls._instance is None: + cls._instance = super().__new__(cls) + cls._instance._initialized = False + return cls._instance + + def __init__(self): + if self._initialized: + return + self._initialized = True + self._clients: Dict[str, MCPClientSession] = {} + self._all_tools: Dict[str, Tuple[MCPToolInfo, MCPClientSession]] = {} + self._all_resources: Dict[str, Tuple[MCPResourceInfo, MCPClientSession]] = {} # v1.2.0 + self._all_prompts: Dict[str, Tuple[MCPPromptInfo, MCPClientSession]] = {} # v1.2.0 + self._settings: Dict[str, Any] = {} + self._lock = asyncio.Lock() + + # 心跳检测任务 + self._heartbeat_task: Optional[asyncio.Task] = None + self._heartbeat_running = False + + # 状态变化回调 + self._on_status_change: Optional[callable] = None + + # 全局统计 + self._global_stats = { + "total_tool_calls": 0, + "successful_calls": 0, + "failed_calls": 0, + "start_time": time.time(), + } + + def configure(self, settings: Dict[str, Any]) -> None: + """配置管理器""" + self._settings = settings + + def set_status_change_callback(self, callback: callable) -> None: + """设置状态变化回调函数""" + self._on_status_change = callback + + def _notify_status_change(self) -> None: + """通知状态变化""" + if self._on_status_change: + try: + self._on_status_change() + except Exception as e: + logger.debug(f"状态变化回调出错: {e}") + + @property + def all_tools(self) -> Dict[str, Tuple[MCPToolInfo, MCPClientSession]]: + """获取所有已注册的工具""" + return self._all_tools.copy() + + @property + def all_resources(self) -> Dict[str, Tuple[MCPResourceInfo, MCPClientSession]]: + """v1.2.0: 获取所有已注册的资源""" + return self._all_resources.copy() + + @property + def all_prompts(self) -> Dict[str, Tuple[MCPPromptInfo, MCPClientSession]]: + """v1.2.0: 获取所有已注册的提示模板""" + return self._all_prompts.copy() + + @property + def connected_servers(self) -> List[str]: + """获取已连接的服务器列表""" + return [name for name, client in self._clients.items() if client.is_connected] + + @property + def disconnected_servers(self) -> List[str]: + """获取已断开的服务器列表""" + return [name for name, client in self._clients.items() if not client.is_connected and client.config.enabled] + + async def add_server(self, config: MCPServerConfig) -> bool: + """添加并连接 MCP 服务器""" + async with self._lock: + if config.name in self._clients: + logger.warning(f"服务器 {config.name} 已存在") + return False + + call_timeout = self._settings.get("call_timeout", 60.0) + client = MCPClientSession(config, call_timeout) + self._clients[config.name] = client + + if not config.enabled: + logger.info(f"服务器 {config.name} 已添加但未启用") + return True + + # 尝试连接 + retry_attempts = self._settings.get("retry_attempts", 3) + retry_interval = self._settings.get("retry_interval", 5.0) + + for attempt in range(1, retry_attempts + 1): + if await client.connect(): + self._register_tools(client) + return True + + if attempt < retry_attempts: + logger.warning(f"服务器 {config.name} 连接失败，{retry_interval}秒后重试 ({attempt}/{retry_attempts})") + await asyncio.sleep(retry_interval) + + logger.error(f"服务器 {config.name} 连接失败，已达最大重试次数 ({retry_attempts})") + # 连接失败，但保留在 _clients 中以便后续重连 + return False + + def _register_tools(self, client: MCPClientSession) -> None: + """注册客户端的工具""" + tool_prefix = self._settings.get("tool_prefix", "mcp") + + for tool in client.tools: + if tool.name.startswith(f"{tool_prefix}_{client.server_name}_"): + tool_key = tool.name + else: + tool_key = f"{tool_prefix}_{client.server_name}_{tool.name}" + self._all_tools[tool_key] = (tool, client) + logger.debug(f"注册 MCP 工具: {tool_key}") + + def _unregister_tools(self, server_name: str) -> List[str]: + """注销服务器的工具，返回被注销的工具键列表""" + tool_prefix = self._settings.get("tool_prefix", "mcp") + prefix = f"{tool_prefix}_{server_name}_" + + keys_to_remove = [k for k in self._all_tools.keys() if k.startswith(prefix)] + for key in keys_to_remove: + del self._all_tools[key] + logger.debug(f"注销 MCP 工具: {key}") + return keys_to_remove + + def _register_resources(self, client: MCPClientSession) -> None: + """v1.2.0: 注册客户端的资源""" + tool_prefix = self._settings.get("tool_prefix", "mcp") + + for resource in client.resources: + # 资源键格式: mcp_{server}_{uri_safe_name} + # 将 URI 转换为安全的键名 + safe_uri = resource.uri.replace("://", "_").replace("/", "_").replace(".", "_") + resource_key = f"{tool_prefix}_{client.server_name}_res_{safe_uri}" + self._all_resources[resource_key] = (resource, client) + logger.debug(f"注册 MCP 资源: {resource_key}") + + def _unregister_resources(self, server_name: str) -> List[str]: + """v1.2.0: 注销服务器的资源""" + tool_prefix = self._settings.get("tool_prefix", "mcp") + prefix = f"{tool_prefix}_{server_name}_res_" + + keys_to_remove = [k for k in self._all_resources.keys() if k.startswith(prefix)] + for key in keys_to_remove: + del self._all_resources[key] + logger.debug(f"注销 MCP 资源: {key}") + return keys_to_remove + + def _register_prompts(self, client: MCPClientSession) -> None: + """v1.2.0: 注册客户端的提示模板""" + tool_prefix = self._settings.get("tool_prefix", "mcp") + + for prompt in client.prompts: + prompt_key = f"{tool_prefix}_{client.server_name}_prompt_{prompt.name}" + self._all_prompts[prompt_key] = (prompt, client) + logger.debug(f"注册 MCP 提示模板: {prompt_key}") + + def _unregister_prompts(self, server_name: str) -> List[str]: + """v1.2.0: 注销服务器的提示模板""" + tool_prefix = self._settings.get("tool_prefix", "mcp") + prefix = f"{tool_prefix}_{server_name}_prompt_" + + keys_to_remove = [k for k in self._all_prompts.keys() if k.startswith(prefix)] + for key in keys_to_remove: + del self._all_prompts[key] + logger.debug(f"注销 MCP 提示模板: {key}") + return keys_to_remove + + async def remove_server(self, server_name: str) -> bool: + """移除 MCP 服务器""" + async with self._lock: + if server_name not in self._clients: + return False + + client = self._clients[server_name] + await client.disconnect() + self._unregister_tools(server_name) + self._unregister_resources(server_name) # v1.2.0 + self._unregister_prompts(server_name) # v1.2.0 + del self._clients[server_name] + + logger.info(f"服务器 {server_name} 已移除") + return True + + async def reconnect_server(self, server_name: str) -> bool: + """重新连接服务器""" + if server_name not in self._clients: + return False + + client = self._clients[server_name] + + async with self._lock: + self._unregister_tools(server_name) + self._unregister_resources(server_name) # v1.2.0 + self._unregister_prompts(server_name) # v1.2.0 + await client.disconnect() + + # 尝试重连 + retry_attempts = self._settings.get("retry_attempts", 3) + retry_interval = self._settings.get("retry_interval", 5.0) + + for attempt in range(1, retry_attempts + 1): + if await client.connect(): + async with self._lock: + self._register_tools(client) + # v1.2.0: 重连后也尝试获取 resources 和 prompts + if self._settings.get("enable_resources", False): + await client.fetch_resources() + self._register_resources(client) + if self._settings.get("enable_prompts", False): + await client.fetch_prompts() + self._register_prompts(client) + client.stats.record_reconnect() + logger.info(f"服务器 {server_name} 重连成功") + return True + + if attempt < retry_attempts: + logger.warning(f"服务器 {server_name} 重连失败，{retry_interval}秒后重试 ({attempt}/{retry_attempts})") + await asyncio.sleep(retry_interval) + + logger.error(f"服务器 {server_name} 重连失败") + return False + + async def call_tool(self, tool_key: str, arguments: Dict[str, Any]) -> MCPCallResult: + """调用 MCP 工具""" + if tool_key not in self._all_tools: + return MCPCallResult( + success=False, + content=None, + error=f"工具 {tool_key} 不存在" + ) + + tool_info, client = self._all_tools[tool_key] + + # 更新全局统计 + self._global_stats["total_tool_calls"] += 1 + + result = await client.call_tool(tool_info.name, arguments) + + if result.success: + self._global_stats["successful_calls"] += 1 + else: + self._global_stats["failed_calls"] += 1 + + return result + + async def fetch_resources_for_server(self, server_name: str) -> bool: + """v1.2.0: 获取指定服务器的资源列表""" + if server_name not in self._clients: + return False + + client = self._clients[server_name] + if not client.is_connected: + return False + + success = await client.fetch_resources() + if success: + async with self._lock: + self._register_resources(client) + return success + + async def fetch_prompts_for_server(self, server_name: str) -> bool: + """v1.2.0: 获取指定服务器的提示模板列表""" + if server_name not in self._clients: + return False + + client = self._clients[server_name] + if not client.is_connected: + return False + + success = await client.fetch_prompts() + if success: + async with self._lock: + self._register_prompts(client) + return success + + async def read_resource(self, uri: str, server_name: Optional[str] = None) -> MCPCallResult: + """v1.2.0: 读取资源内容 + + Args: + uri: 资源 URI + server_name: 指定服务器名称（可选，不指定则自动查找） + """ + # 如果指定了服务器 + if server_name: + if server_name not in self._clients: + return MCPCallResult( + success=False, + content=None, + error=f"服务器 {server_name} 不存在" + ) + client = self._clients[server_name] + return await client.read_resource(uri) + + # 自动查找拥有该资源的服务器 + for resource_key, (resource_info, client) in self._all_resources.items(): + if resource_info.uri == uri: + return await client.read_resource(uri) + + # 尝试在所有支持 resources 的服务器上查找 + for client in self._clients.values(): + if client.is_connected and client.supports_resources: + result = await client.read_resource(uri) + if result.success: + return result + + return MCPCallResult( + success=False, + content=None, + error=f"未找到资源: {uri}" + ) + + async def get_prompt(self, name: str, arguments: Optional[Dict[str, str]] = None, + server_name: Optional[str] = None) -> MCPCallResult: + """v1.2.0: 获取提示模板内容 + + Args: + name: 提示模板名称 + arguments: 模板参数 + server_name: 指定服务器名称（可选） + """ + # 如果指定了服务器 + if server_name: + if server_name not in self._clients: + return MCPCallResult( + success=False, + content=None, + error=f"服务器 {server_name} 不存在" + ) + client = self._clients[server_name] + return await client.get_prompt(name, arguments) + + # 自动查找拥有该提示模板的服务器 + for prompt_key, (prompt_info, client) in self._all_prompts.items(): + if prompt_info.name == name: + return await client.get_prompt(name, arguments) + + return MCPCallResult( + success=False, + content=None, + error=f"未找到提示模板: {name}" + ) + + # ==================== 心跳检测 ==================== + + async def start_heartbeat(self) -> None: + """启动心跳检测任务""" + if self._heartbeat_running: + logger.warning("心跳检测任务已在运行") + return + + heartbeat_enabled = self._settings.get("heartbeat_enabled", True) + if not heartbeat_enabled: + logger.info("心跳检测已禁用") + return + + self._heartbeat_running = True + self._heartbeat_task = asyncio.create_task(self._heartbeat_loop()) + logger.info("心跳检测任务已启动") + + async def stop_heartbeat(self) -> None: + """停止心跳检测任务""" + self._heartbeat_running = False + if self._heartbeat_task: + self._heartbeat_task.cancel() + try: + await self._heartbeat_task + except asyncio.CancelledError: + pass + self._heartbeat_task = None + logger.info("心跳检测任务已停止") + + async def _heartbeat_loop(self) -> None: + """心跳检测循环（v1.5.2: 智能心跳间隔）""" + base_interval = self._settings.get("heartbeat_interval", 60.0) + auto_reconnect = self._settings.get("auto_reconnect", True) + max_reconnect_attempts = self._settings.get("max_reconnect_attempts", 3) + + # v1.5.2: 智能心跳配置 + adaptive_enabled = self._settings.get("heartbeat_adaptive", True) + max_multiplier = self._settings.get("heartbeat_max_multiplier", 3.0) + + # 每个服务器独立的心跳间隔（根据稳定性动态调整） + server_intervals: Dict[str, float] = {} + min_interval = max(base_interval * 0.5, 30.0) # 最小间隔 + max_interval = base_interval * max_multiplier # 最大间隔 + + mode_str = "智能" if adaptive_enabled else "固定" + logger.info(f"心跳检测循环启动，{mode_str}模式，基准间隔: {base_interval}秒") + + while self._heartbeat_running: + try: + # 使用最小的服务器间隔作为循环间隔 + current_interval = min(server_intervals.values()) if server_intervals else base_interval + current_interval = max(current_interval, min_interval) + + await asyncio.sleep(current_interval) + + if not self._heartbeat_running: + break + + current_time = time.time() + + # 检查所有已启用的服务器 + for server_name, client in list(self._clients.items()): + if not client.config.enabled: + continue + + # 初始化服务器间隔 + if server_name not in server_intervals: + server_intervals[server_name] = base_interval + + # 检查是否到达该服务器的心跳时间 + last_heartbeat = client.stats.last_heartbeat_time or 0 + if current_time - last_heartbeat < server_intervals[server_name] * 0.9: + continue # 还没到心跳时间 + + if client.is_connected: + # 检查健康状态 + healthy = await client.check_health() + if healthy: + # v1.5.2: 智能心跳 - 稳定服务器逐渐增加间隔 + if adaptive_enabled and client.stats.consecutive_failures == 0: + new_interval = min(server_intervals[server_name] * 1.2, max_interval) + if new_interval != server_intervals[server_name]: + server_intervals[server_name] = new_interval + logger.debug(f"[{server_name}] 稳定，心跳间隔调整为 {new_interval:.0f}s") + else: + logger.warning(f"[{server_name}] 心跳检测失败，连接可能已断开") + # 失败后重置为基准间隔 + if adaptive_enabled: + server_intervals[server_name] = base_interval + self._notify_status_change() + if auto_reconnect: + await self._try_reconnect(server_name, max_reconnect_attempts) + else: + # 服务器未连接，尝试重连 + if adaptive_enabled: + # 智能心跳：断开的服务器使用较短间隔 + server_intervals[server_name] = min_interval + if auto_reconnect and client.stats.consecutive_failures < max_reconnect_attempts: + logger.info(f"[{server_name}] 检测到断开，尝试重连...") + await self._try_reconnect(server_name, max_reconnect_attempts) + elif client.stats.consecutive_failures >= max_reconnect_attempts: + if adaptive_enabled: + # 达到最大重连次数，降低检测频率 + server_intervals[server_name] = max_interval + logger.debug(f"[{server_name}] 已达最大重连次数，降低检测频率") + + except asyncio.CancelledError: + break + except Exception as e: + logger.error(f"心跳检测循环出错: {e}") + await asyncio.sleep(5) + + async def _try_reconnect(self, server_name: str, max_attempts: int) -> bool: + """尝试重连服务器""" + client = self._clients.get(server_name) + if not client: + return False + + if client.stats.consecutive_failures >= max_attempts: + logger.warning(f"[{server_name}] 连续失败次数已达上限 ({max_attempts})，暂停重连") + return False + + logger.info(f"[{server_name}] 尝试重连 (失败次数: {client.stats.consecutive_failures}/{max_attempts})") + + success = await self.reconnect_server(server_name) + if not success: + client.stats.record_failure() + + self._notify_status_change() # 重连后更新状态 + return success + + # ==================== 统计和状态 ==================== + + def get_tool_stats(self, tool_key: str) -> Optional[Dict[str, Any]]: + """获取指定工具的统计信息""" + if tool_key not in self._all_tools: + return None + + tool_info, client = self._all_tools[tool_key] + stats = client.get_tool_stats(tool_info.name) + return stats.to_dict() if stats else None + + def get_all_stats(self) -> Dict[str, Any]: + """获取所有统计信息""" + server_stats = {} + tool_stats = {} + + for server_name, client in self._clients.items(): + server_stats[server_name] = client.stats.to_dict() + for tool_name, stats in client.get_all_tool_stats().items(): + full_key = f"{self._settings.get('tool_prefix', 'mcp')}_{server_name}_{tool_name}" + tool_stats[full_key] = stats.to_dict() + + uptime = time.time() - self._global_stats["start_time"] + + return { + "global": { + **self._global_stats, + "uptime_seconds": round(uptime, 2), + "calls_per_minute": round(self._global_stats["total_tool_calls"] / (uptime / 60), 2) if uptime > 0 else 0, + }, + "servers": server_stats, + "tools": tool_stats, + } + + async def shutdown(self) -> None: + """关闭所有连接""" + # 停止心跳检测 + await self.stop_heartbeat() + + async with self._lock: + for client in self._clients.values(): + await client.disconnect() + self._clients.clear() + self._all_tools.clear() + self._all_resources.clear() # v1.2.0 + self._all_prompts.clear() # v1.2.0 + logger.info("MCP 客户端管理器已关闭") + + def get_status(self) -> Dict[str, Any]: + """获取状态信息""" + return { + "total_servers": len(self._clients), + "connected_servers": len(self.connected_servers), + "disconnected_servers": len(self.disconnected_servers), + "total_tools": len(self._all_tools), + "total_resources": len(self._all_resources), # v1.2.0 + "total_prompts": len(self._all_prompts), # v1.2.0 + "heartbeat_running": self._heartbeat_running, + "servers": { + name: { + "connected": client.is_connected, + "enabled": client.config.enabled, + "tools_count": len(client.tools), + "resources_count": len(client.resources), # v1.2.0 + "prompts_count": len(client.prompts), # v1.2.0 + "supports_resources": client.supports_resources, # v1.2.0 + "supports_prompts": client.supports_prompts, # v1.2.0 + "transport": client.config.transport.value, + "consecutive_failures": client.stats.consecutive_failures, + "circuit_breaker": client.get_circuit_breaker_status(), # v1.7.0 + } + for name, client in self._clients.items() + }, + "global_stats": self._global_stats, + } + + +# 全局单例 +mcp_manager = MCPClientManager() diff --git a/plugins/MaiBot_MCPBridgePlugin/plugin.py b/plugins/MaiBot_MCPBridgePlugin/plugin.py new file mode 100644 index 00000000..06055c6b --- /dev/null +++ b/plugins/MaiBot_MCPBridgePlugin/plugin.py @@ -0,0 +1,3722 @@ +""" +MCP 桥接插件 v2.0.0 +将 MCP (Model Context Protocol) 服务器的工具桥接到 MaiBot + +v2.0.0 配置与架构精简（功能保持不变）: +- MCP 服务器配置统一为 Claude Desktop 的 mcpServers JSON（WebUI / config.toml 同一入口） +- 兼容迁移：检测到旧版 servers.list 时自动迁移为 mcpServers（仅迁移，避免多入口混淆） +- 移除 WebUI 导入导出/快速添加服务器的旧实现（避免 tomlkit 依赖与格式混乱） + +v1.9.0 双轨制架构: +- 软流程 (ReAct): LLM 自主决策，动态多轮调用 MCP 工具，灵活应对复杂场景 +- 硬流程 (Workflow): 用户预定义的工作流，固定执行顺序，可靠可控 +- 工具链重命名为 Workflow，更清晰地表达其"预定义流程"的本质 +- 命令更新：/mcp workflow 替代 /mcp chain + +v1.8.1 工具链易用性优化: +- 快速添加工具链：WebUI 表单式配置，无需手写 JSON +- 工具链模板：提供常用工具链配置模板参考 +- 使用指南：内置变量语法和命令说明 +- 状态显示优化：详细展示工具链步骤和参数信息 + +v1.8.0 工具链支持: +- 工具链：将多个工具按顺序执行，后续工具可使用前序工具的输出 +- 自定义工具链：在 WebUI 配置工具链，自动注册为组合工具供 LLM 调用 +- 变量替换：支持 ${input.参数}、${step.输出键}、${prev} 变量 +- 工具链命令：/mcp chain 查看、测试、管理工具链 + +v1.7.0 稳定性与易用性优化: +- 断路器模式：故障服务器快速失败，避免拖慢整体响应 +- 状态实时刷新：WebUI 每 10 秒自动更新连接状态 +- 断路器状态显示：在状态面板显示熔断/试探状态 + +v1.6.0 配置导入导出: +- 新增 /mcp import 命令，支持从 Claude Desktop 格式导入配置 +- 新增 /mcp export 命令，导出为 Claude Desktop (mcpServers) 格式 +- 支持 stdio、sse、http、streamable_http 全部传输类型 +- 自动跳过同名服务器，防止重复导入 + +v1.5.4 易用性优化: +- 新增 MCP 服务器获取快捷入口（魔搭、Smithery、Glama 等） +- 优化快速入门指南，提供配置示例 +- 帮助新用户快速上手 MCP + +v1.5.3 配置优化: +- 新增智能心跳 WebUI 配置项：启用开关、最大间隔倍数 +- 支持在 WebUI 中开启/关闭智能心跳功能 + +v1.5.2 性能优化: +- 智能心跳间隔：根据服务器稳定性动态调整心跳频率 +- 稳定服务器逐渐增加间隔，减少不必要的网络请求 +- 断开的服务器使用较短间隔快速重连 + +v1.5.1 易用性优化（v2.0.0 起已移除）: +- 「快速添加服务器」表单式配置（已统一为 Claude mcpServers JSON，避免多入口混淆） + +v1.5.0 性能优化: +- 服务器并行连接：多个服务器同时连接，大幅减少启动时间 +- 连接耗时统计：日志显示并行连接总耗时 + +v1.4.4 修复: +- 修复首次生成默认配置文件时多行字符串导致 TOML 解析失败的问题 +- 简化 config_schema 默认值，避免主程序 json.dumps 产生无效 TOML + +v1.4.3 修复: +- 修复 WebUI 保存配置后多行字符串格式错误导致配置文件无法读取的问题 +- 清理未使用的导入 + +v1.4.0 新增功能: +- 工具禁用管理 +- 调用链路追踪 +- 工具调用缓存 +- 工具权限控制 +""" + +import asyncio +import fnmatch +import hashlib +import json +import re +import time +import uuid +from collections import OrderedDict, deque +from dataclasses import asdict, dataclass, field +from pathlib import Path +from typing import Any, Dict, List, Optional, Tuple, Type + +from src.common.logger import get_logger +from src.plugin_system import ( + BasePlugin, + register_plugin, + BaseTool, + BaseCommand, + ComponentInfo, + ConfigField, + ToolParamType, +) +from src.plugin_system.base.config_types import section_meta +from src.plugin_system.base.component_types import ToolInfo, ComponentType, EventType +from src.plugin_system.base.base_events_handler import BaseEventHandler + +from .mcp_client import ( + MCPServerConfig, + MCPToolInfo, + MCPResourceInfo, + MCPPromptInfo, + TransportType, + mcp_manager, +) +from .core.claude_config import ( + ClaudeConfigError, + legacy_servers_list_to_claude_config, + parse_claude_mcp_config, +) +from .tool_chain import ( + ToolChainDefinition, + ToolChainStep, + ChainExecutionResult, + tool_chain_manager, +) + +logger = get_logger("mcp_bridge_plugin") + + +# ============================================================================ +# v1.4.0: 调用链路追踪 +# ============================================================================ + +@dataclass +class ToolCallRecord: + """工具调用记录""" + call_id: str + timestamp: float + tool_name: str + server_name: str + chat_id: str = "" + user_id: str = "" + user_query: str = "" + arguments: Dict = field(default_factory=dict) + raw_result: str = "" + processed_result: str = "" + duration_ms: float = 0.0 + success: bool = True + error: str = "" + post_processed: bool = False + cache_hit: bool = False + + +class ToolCallTracer: + """工具调用追踪器""" + + def __init__(self, max_records: int = 100): + self._records: deque[ToolCallRecord] = deque(maxlen=max_records) + self._enabled: bool = True + self._log_enabled: bool = False + self._log_path: Optional[Path] = None + + def configure(self, enabled: bool, max_records: int, log_enabled: bool, log_path: Optional[Path] = None) -> None: + """配置追踪器""" + self._enabled = enabled + self._records = deque(self._records, maxlen=max_records) + self._log_enabled = log_enabled + self._log_path = log_path + + def record(self, record: ToolCallRecord) -> None: + """添加调用记录""" + if not self._enabled: + return + + self._records.append(record) + + if self._log_enabled and self._log_path: + self._write_to_log(record) + + def get_recent(self, n: int = 10) -> List[ToolCallRecord]: + """获取最近 N 条记录""" + return list(self._records)[-n:] + + def get_by_tool(self, tool_name: str) -> List[ToolCallRecord]: + """按工具名筛选记录""" + return [r for r in self._records if r.tool_name == tool_name] + + def get_by_server(self, server_name: str) -> List[ToolCallRecord]: + """按服务器名筛选记录""" + return [r for r in self._records if r.server_name == server_name] + + def clear(self) -> None: + """清空记录""" + self._records.clear() + + def _write_to_log(self, record: ToolCallRecord) -> None: + """写入 JSONL 日志文件""" + try: + if self._log_path: + self._log_path.parent.mkdir(parents=True, exist_ok=True) + with open(self._log_path, "a", encoding="utf-8") as f: + f.write(json.dumps(asdict(record), ensure_ascii=False) + "\n") + except Exception as e: + logger.warning(f"写入追踪日志失败: {e}") + + @property + def total_records(self) -> int: + return len(self._records) + + +# 全局追踪器实例 +tool_call_tracer = ToolCallTracer() + + +# ============================================================================ +# v1.4.0: 工具调用缓存 +# ============================================================================ + +@dataclass +class CacheEntry: + """缓存条目""" + tool_name: str + args_hash: str + result: str + created_at: float + expires_at: float + hit_count: int = 0 + + +class ToolCallCache: + """工具调用缓存（LRU）""" + + def __init__(self, max_entries: int = 200, ttl: int = 300): + self._cache: OrderedDict[str, CacheEntry] = OrderedDict() + self._max_entries = max_entries + self._ttl = ttl + self._enabled = False + self._exclude_patterns: List[str] = [] + self._stats = {"hits": 0, "misses": 0} + + def configure(self, enabled: bool, ttl: int, max_entries: int, exclude_tools: str) -> None: + """配置缓存""" + self._enabled = enabled + self._ttl = ttl + self._max_entries = max_entries + self._exclude_patterns = [p.strip() for p in exclude_tools.strip().split("\n") if p.strip()] + + def get(self, tool_name: str, args: Dict) -> Optional[str]: + """获取缓存""" + if not self._enabled: + return None + + if self._is_excluded(tool_name): + return None + + key = self._generate_key(tool_name, args) + + if key not in self._cache: + self._stats["misses"] += 1 + return None + + entry = self._cache[key] + + # 检查是否过期 + if time.time() > entry.expires_at: + del self._cache[key] + self._stats["misses"] += 1 + return None + + # LRU: 移到末尾 + self._cache.move_to_end(key) + entry.hit_count += 1 + self._stats["hits"] += 1 + + return entry.result + + def set(self, tool_name: str, args: Dict, result: str) -> None: + """设置缓存""" + if not self._enabled: + return + + if self._is_excluded(tool_name): + return + + key = self._generate_key(tool_name, args) + now = time.time() + + entry = CacheEntry( + tool_name=tool_name, + args_hash=key, + result=result, + created_at=now, + expires_at=now + self._ttl, + ) + + # 如果已存在，更新 + if key in self._cache: + self._cache[key] = entry + self._cache.move_to_end(key) + else: + # 检查容量 + self._evict_if_needed() + self._cache[key] = entry + + def clear(self) -> None: + """清空缓存""" + self._cache.clear() + self._stats = {"hits": 0, "misses": 0} + + def _generate_key(self, tool_name: str, args: Dict) -> str: + """生成缓存键""" + args_str = json.dumps(args, sort_keys=True, ensure_ascii=False) + content = f"{tool_name}:{args_str}" + return hashlib.md5(content.encode()).hexdigest() + + def _is_excluded(self, tool_name: str) -> bool: + """检查是否在排除列表中""" + for pattern in self._exclude_patterns: + if fnmatch.fnmatch(tool_name, pattern): + return True + return False + + def _evict_if_needed(self) -> None: + """必要时淘汰条目""" + # 先清理过期的 + now = time.time() + expired_keys = [k for k, v in self._cache.items() if now > v.expires_at] + for k in expired_keys: + del self._cache[k] + + # LRU 淘汰 + while len(self._cache) >= self._max_entries: + self._cache.popitem(last=False) + + def get_stats(self) -> Dict[str, Any]: + """获取缓存统计""" + total = self._stats["hits"] + self._stats["misses"] + hit_rate = (self._stats["hits"] / total * 100) if total > 0 else 0 + return { + "enabled": self._enabled, + "entries": len(self._cache), + "max_entries": self._max_entries, + "ttl": self._ttl, + "hits": self._stats["hits"], + "misses": self._stats["misses"], + "hit_rate": f"{hit_rate:.1f}%", + } + + +# 全局缓存实例 +tool_call_cache = ToolCallCache() + + +# ============================================================================ +# v1.4.0: 工具权限控制 +# ============================================================================ + +class PermissionChecker: + """工具权限检查器""" + + def __init__(self): + self._enabled = False + self._default_mode = "allow_all" # allow_all 或 deny_all + self._rules: List[Dict] = [] + self._quick_deny_groups: set = set() + self._quick_allow_users: set = set() + + def configure( + self, + enabled: bool, + default_mode: str, + rules_json: str, + quick_deny_groups: str = "", + quick_allow_users: str = "", + ) -> None: + """配置权限检查器""" + self._enabled = enabled + self._default_mode = default_mode if default_mode in ("allow_all", "deny_all") else "allow_all" + + # 解析快捷配置 + self._quick_deny_groups = {g.strip() for g in quick_deny_groups.strip().split("\n") if g.strip()} + self._quick_allow_users = {u.strip() for u in quick_allow_users.strip().split("\n") if u.strip()} + + try: + self._rules = json.loads(rules_json) if rules_json.strip() else [] + except json.JSONDecodeError as e: + logger.warning(f"权限规则 JSON 解析失败: {e}") + self._rules = [] + + def check(self, tool_name: str, chat_id: str, user_id: str, is_group: bool) -> bool: + """检查权限 + + Args: + tool_name: 工具名称 + chat_id: 聊天 ID（群号或私聊 ID） + user_id: 用户 ID + is_group: 是否为群聊 + + Returns: + True 表示允许，False 表示拒绝 + """ + if not self._enabled: + return True + + # 快捷配置优先级最高 + # 1. 管理员白名单（始终允许） + if user_id and user_id in self._quick_allow_users: + return True + + # 2. 禁用群列表（始终拒绝） + if is_group and chat_id and chat_id in self._quick_deny_groups: + return False + + # 查找匹配的规则 + for rule in self._rules: + tool_pattern = rule.get("tool", "") + if not self._match_tool(tool_pattern, tool_name): + continue + + # 找到匹配的规则 + mode = rule.get("mode", "") + allowed = rule.get("allowed", []) + denied = rule.get("denied", []) + + # 构建当前上下文的 ID 列表 + context_ids = self._build_context_ids(chat_id, user_id, is_group) + + # 检查 denied 列表（优先级最高） + if denied: + for ctx_id in context_ids: + if self._match_id_list(denied, ctx_id): + return False + + # 检查 allowed 列表 + if allowed: + for ctx_id in context_ids: + if self._match_id_list(allowed, ctx_id): + return True + # 如果是 whitelist 模式且不在 allowed 中，拒绝 + if mode == "whitelist": + return False + + # 规则匹配但没有明确允许/拒绝，继续检查下一条规则 + + # 没有匹配的规则，使用默认模式 + return self._default_mode == "allow_all" + + def _match_tool(self, pattern: str, tool_name: str) -> bool: + """工具名通配符匹配""" + if not pattern: + return False + return fnmatch.fnmatch(tool_name, pattern) + + def _build_context_ids(self, chat_id: str, user_id: str, is_group: bool) -> List[str]: + """构建上下文 ID 列表""" + ids = [] + + # 用户级别（任何场景生效） + if user_id: + ids.append(f"qq:{user_id}:user") + + # 场景级别 + if is_group and chat_id: + ids.append(f"qq:{chat_id}:group") + elif chat_id: + ids.append(f"qq:{chat_id}:private") + + return ids + + def _match_id_list(self, id_list: List[str], context_id: str) -> bool: + """检查 ID 是否在列表中""" + for rule_id in id_list: + if fnmatch.fnmatch(context_id, rule_id): + return True + return False + + def get_rules_for_tool(self, tool_name: str) -> List[Dict]: + """获取特定工具的权限规则""" + return [r for r in self._rules if self._match_tool(r.get("tool", ""), tool_name)] + + +# 全局权限检查器实例 +permission_checker = PermissionChecker() + + +# ============================================================================ +# 工具类型转换 +# ============================================================================ + +def convert_json_type_to_tool_param_type(json_type: str) -> ToolParamType: + """将 JSON Schema 类型转换为 MaiBot 的 ToolParamType""" + type_mapping = { + "string": ToolParamType.STRING, + "integer": ToolParamType.INTEGER, + "number": ToolParamType.FLOAT, + "boolean": ToolParamType.BOOLEAN, + "array": ToolParamType.STRING, + "object": ToolParamType.STRING, + } + return type_mapping.get(json_type, ToolParamType.STRING) + + +def parse_mcp_parameters(input_schema: Dict[str, Any]) -> List[Tuple[str, ToolParamType, str, bool, Optional[List[str]]]]: + """解析 MCP 工具的参数 schema，转换为 MaiBot 的参数格式""" + parameters = [] + + if not input_schema: + # 为无参数的工具添加占位参数，避免某些模型报错 + parameters.append(("_placeholder", ToolParamType.STRING, "占位参数，无需填写", False, None)) + return parameters + + properties = input_schema.get("properties", {}) + required = input_schema.get("required", []) + + # 如果没有任何参数，添加占位参数 + if not properties: + parameters.append(("_placeholder", ToolParamType.STRING, "占位参数，无需填写", False, None)) + return parameters + + for param_name, param_info in properties.items(): + json_type = param_info.get("type", "string") + param_type = convert_json_type_to_tool_param_type(json_type) + description = param_info.get("description", f"参数 {param_name}") + + if json_type == "array": + description = f"{description} (JSON 数组格式)" + elif json_type == "object": + description = f"{description} (JSON 对象格式)" + + is_required = param_name in required + enum_values = param_info.get("enum") + + if enum_values is not None: + enum_values = [str(v) for v in enum_values] + + parameters.append((param_name, param_type, description, is_required, enum_values)) + + return parameters + + +# ============================================================================ +# MCP 工具代理 +# ============================================================================ + +class MCPToolProxy(BaseTool): + """MCP 工具代理基类""" + + name: str = "" + description: str = "" + parameters: List[Tuple[str, ToolParamType, str, bool, Optional[List[str]]]] = [] + available_for_llm: bool = True + + _mcp_tool_key: str = "" + _mcp_original_name: str = "" + _mcp_server_name: str = "" + + async def execute(self, function_args: Dict[str, Any]) -> Dict[str, Any]: + """执行 MCP 工具调用""" + global _plugin_instance + + call_id = str(uuid.uuid4())[:8] + start_time = time.time() + + # 移除 MaiBot 内部标记 + args = {k: v for k, v in function_args.items() if k != "llm_called"} + + # 解析 JSON 字符串参数 + parsed_args = {} + for key, value in args.items(): + if isinstance(value, str): + try: + if value.startswith(("[", "{")): + parsed_args[key] = json.loads(value) + else: + parsed_args[key] = value + except json.JSONDecodeError: + parsed_args[key] = value + else: + parsed_args[key] = value + + # 获取上下文信息 + chat_id, user_id, is_group, user_query = self._get_context_info() + + # v1.4.0: 权限检查 + if not permission_checker.check(self.name, chat_id, user_id, is_group): + logger.warning(f"权限拒绝: 工具 {self.name}, chat={chat_id}, user={user_id}") + return { + "name": self.name, + "content": f"⛔ 权限不足：工具 {self.name} 在当前场景下不可用" + } + + logger.debug(f"调用 MCP 工具: {self._mcp_tool_key}, 参数: {parsed_args}") + + # v1.4.0: 检查缓存 + cache_hit = False + cached_result = tool_call_cache.get(self.name, parsed_args) + + if cached_result is not None: + cache_hit = True + content = cached_result + raw_result = cached_result + success = True + error = "" + logger.debug(f"MCP 工具 {self.name} 命中缓存") + else: + # 调用 MCP + result = await mcp_manager.call_tool(self._mcp_tool_key, parsed_args) + + if result.success: + content = result.content + raw_result = content + success = True + error = "" + + # 存入缓存 + tool_call_cache.set(self.name, parsed_args, content) + else: + content = self._format_error_message(result.error, result.duration_ms) + raw_result = result.error + success = False + error = result.error + logger.warning(f"MCP 工具 {self.name} 调用失败: {result.error}") + + # v1.3.0: 后处理 + post_processed = False + processed_result = content + if success: + processed_content = await self._post_process_result(content) + if processed_content != content: + post_processed = True + processed_result = processed_content + content = processed_content + + duration_ms = (time.time() - start_time) * 1000 + + # v1.4.0: 记录调用追踪 + record = ToolCallRecord( + call_id=call_id, + timestamp=start_time, + tool_name=self.name, + server_name=self._mcp_server_name, + chat_id=chat_id, + user_id=user_id, + user_query=user_query, + arguments=parsed_args, + raw_result=raw_result[:1000] if raw_result else "", + processed_result=processed_result[:1000] if processed_result else "", + duration_ms=duration_ms, + success=success, + error=error, + post_processed=post_processed, + cache_hit=cache_hit, + ) + tool_call_tracer.record(record) + + return {"name": self.name, "content": content} + + def _get_context_info(self) -> Tuple[str, str, bool, str]: + """获取上下文信息""" + chat_id = "" + user_id = "" + is_group = False + user_query = "" + + if self.chat_stream and hasattr(self.chat_stream, "context") and self.chat_stream.context: + try: + ctx = self.chat_stream.context + if hasattr(ctx, "chat_id"): + chat_id = str(ctx.chat_id) if ctx.chat_id else "" + if hasattr(ctx, "user_id"): + user_id = str(ctx.user_id) if ctx.user_id else "" + if hasattr(ctx, "is_group"): + is_group = bool(ctx.is_group) + + last_message = ctx.get_last_message() + if last_message and hasattr(last_message, "processed_plain_text"): + user_query = last_message.processed_plain_text or "" + except Exception as e: + logger.debug(f"获取上下文信息失败: {e}") + + return chat_id, user_id, is_group, user_query + + async def _post_process_result(self, content: str) -> str: + """v1.3.0: 对工具返回结果进行后处理（摘要提炼）""" + global _plugin_instance + + if _plugin_instance is None: + return content + + settings = _plugin_instance.config.get("settings", {}) + + if not settings.get("post_process_enabled", False): + return content + + server_post_config = self._get_server_post_process_config() + + if server_post_config is not None: + if not server_post_config.get("enabled", True): + return content + + threshold = settings.get("post_process_threshold", 500) + if server_post_config and "threshold" in server_post_config: + threshold = server_post_config["threshold"] + + content_length = len(content) if content else 0 + if content_length <= threshold: + return content + + user_query = self._get_context_info()[3] + if not user_query: + return content + + max_tokens = settings.get("post_process_max_tokens", 500) + if server_post_config and "max_tokens" in server_post_config: + max_tokens = server_post_config["max_tokens"] + + prompt_template = settings.get("post_process_prompt", "") + if server_post_config and "prompt" in server_post_config: + prompt_template = server_post_config["prompt"] + + if not prompt_template: + prompt_template = """用户问题：{query} + +工具返回内容： +{result} + +请从上述内容中提取与用户问题最相关的关键信息，简洁准确地输出：""" + + try: + prompt = prompt_template.format(query=user_query, result=content) + except KeyError as e: + logger.warning(f"后处理 prompt 模板格式错误: {e}") + return content + + try: + processed_content = await self._call_post_process_llm(prompt, max_tokens, settings, server_post_config) + if processed_content: + logger.info(f"MCP 工具 {self.name} 后处理完成: {content_length} -> {len(processed_content)} 字符") + return processed_content + return content + except Exception as e: + logger.error(f"MCP 工具 {self.name} 后处理失败: {e}") + return content + + def _get_server_post_process_config(self) -> Optional[Dict[str, Any]]: + """获取当前服务器的后处理配置""" + global _plugin_instance + + if _plugin_instance is None: + return None + + servers = _plugin_instance._load_mcp_servers_config() + for server_conf in servers: + if server_conf.get("name") == self._mcp_server_name: + return server_conf.get("post_process") + + return None + + async def _call_post_process_llm( + self, + prompt: str, + max_tokens: int, + settings: Dict[str, Any], + server_config: Optional[Dict[str, Any]] + ) -> Optional[str]: + """调用 LLM 进行后处理""" + from src.config.config import model_config + from src.config.api_ada_configs import TaskConfig + from src.llm_models.utils_model import LLMRequest + + model_name = settings.get("post_process_model", "") + if server_config and "model" in server_config: + model_name = server_config["model"] + + if model_name: + task_config = TaskConfig( + model_list=[model_name], + max_tokens=max_tokens, + temperature=0.3, + slow_threshold=30.0, + ) + else: + task_config = model_config.model_task_config.utils + + llm_request = LLMRequest(model_set=task_config, request_type="mcp_post_process") + + response, (reasoning, model_used, _) = await llm_request.generate_response_async( + prompt=prompt, + max_tokens=max_tokens, + temperature=0.3, + ) + + return response.strip() if response else None + + def _format_error_message(self, error: str, duration_ms: float) -> str: + """格式化友好的错误消息""" + if not error: + return "工具调用失败（未知错误）" + + error_lower = error.lower() + + if "未连接" in error or "not connected" in error_lower: + return f"⚠️ MCP 服务器 [{self._mcp_server_name}] 未连接，请检查服务器状态或等待自动重连" + + if "超时" in error or "timeout" in error_lower: + return f"⏱️ 工具调用超时（耗时 {duration_ms:.0f}ms），服务器响应过慢，请稍后重试" + + if "connection" in error_lower and ("closed" in error_lower or "reset" in error_lower): + return f"🔌 与 MCP 服务器 [{self._mcp_server_name}] 的连接已断开，正在尝试重连..." + + if "invalid" in error_lower and "argument" in error_lower: + return f"❌ 参数错误: {error}" + + return f"❌ 工具调用失败: {error}" + + async def direct_execute(self, **function_args) -> Dict[str, Any]: + """直接执行（供其他插件调用）""" + return await self.execute(function_args) + + +def create_mcp_tool_class( + tool_key: str, + tool_info: MCPToolInfo, + tool_prefix: str, + disabled: bool = False +) -> Type[MCPToolProxy]: + """根据 MCP 工具信息动态创建 BaseTool 子类""" + parameters = parse_mcp_parameters(tool_info.input_schema) + + class_name = f"MCPTool_{tool_info.server_name}_{tool_info.name}".replace("-", "_").replace(".", "_") + tool_name = tool_key.replace("-", "_").replace(".", "_") + + description = tool_info.description + if not description.endswith(f"[来自 MCP 服务器: {tool_info.server_name}]"): + description = f"{description} [来自 MCP 服务器: {tool_info.server_name}]" + + tool_class = type( + class_name, + (MCPToolProxy,), + { + "name": tool_name, + "description": description, + "parameters": parameters, + "available_for_llm": not disabled, # v1.4.0: 禁用的工具不可被 LLM 调用 + "_mcp_tool_key": tool_key, + "_mcp_original_name": tool_info.name, + "_mcp_server_name": tool_info.server_name, + } + ) + + return tool_class + + +class MCPToolRegistry: + """MCP 工具注册表""" + + def __init__(self): + self._tool_classes: Dict[str, Type[MCPToolProxy]] = {} + self._tool_infos: Dict[str, ToolInfo] = {} + + def register_tool( + self, + tool_key: str, + tool_info: MCPToolInfo, + tool_prefix: str, + disabled: bool = False + ) -> Tuple[ToolInfo, Type[MCPToolProxy]]: + """注册 MCP 工具""" + tool_class = create_mcp_tool_class(tool_key, tool_info, tool_prefix, disabled) + + self._tool_classes[tool_key] = tool_class + + info = ToolInfo( + name=tool_class.name, + tool_description=tool_class.description, + enabled=True, + tool_parameters=tool_class.parameters, + component_type=ComponentType.TOOL, + ) + self._tool_infos[tool_key] = info + + return info, tool_class + + def unregister_tool(self, tool_key: str) -> bool: + """注销工具""" + if tool_key in self._tool_classes: + del self._tool_classes[tool_key] + del self._tool_infos[tool_key] + return True + return False + + def get_all_components(self) -> List[Tuple[ComponentInfo, Type]]: + """获取所有工具组件""" + return [(self._tool_infos[key], self._tool_classes[key]) for key in self._tool_classes.keys()] + + def clear(self) -> None: + """清空所有注册""" + self._tool_classes.clear() + self._tool_infos.clear() + + +# 全局工具注册表 +mcp_tool_registry = MCPToolRegistry() + +# 全局插件实例引用 +_plugin_instance: Optional["MCPBridgePlugin"] = None + + +# ============================================================================ +# 内置工具 +# ============================================================================ + +class MCPReadResourceTool(BaseTool): + """v1.2.0: MCP 资源读取工具""" + + name = "mcp_read_resource" + description = "读取 MCP 服务器提供的资源内容（如文件、数据库记录等）。使用前请先用 mcp_status 查看可用资源。" + parameters = [ + ("uri", ToolParamType.STRING, "资源 URI（如 file:///path/to/file 或自定义 URI）", True, None), + ("server_name", ToolParamType.STRING, "指定服务器名称（可选，不指定则自动查找）", False, None), + ] + available_for_llm = True + + async def execute(self, function_args: Dict[str, Any]) -> Dict[str, Any]: + uri = function_args.get("uri", "") + server_name = function_args.get("server_name") + + if not uri: + return {"name": self.name, "content": "❌ 请提供资源 URI"} + + result = await mcp_manager.read_resource(uri, server_name) + + if result.success: + return {"name": self.name, "content": result.content} + else: + return {"name": self.name, "content": f"❌ 读取资源失败: {result.error}"} + + async def direct_execute(self, **function_args) -> Dict[str, Any]: + return await self.execute(function_args) + + +class MCPGetPromptTool(BaseTool): + """v1.2.0: MCP 提示模板工具""" + + name = "mcp_get_prompt" + description = "获取 MCP 服务器提供的提示模板内容。使用前请先用 mcp_status 查看可用模板。" + parameters = [ + ("name", ToolParamType.STRING, "提示模板名称", True, None), + ("arguments", ToolParamType.STRING, "模板参数（JSON 对象格式）", False, None), + ("server_name", ToolParamType.STRING, "指定服务器名称（可选）", False, None), + ] + available_for_llm = True + + async def execute(self, function_args: Dict[str, Any]) -> Dict[str, Any]: + prompt_name = function_args.get("name", "") + arguments_str = function_args.get("arguments", "") + server_name = function_args.get("server_name") + + if not prompt_name: + return {"name": self.name, "content": "❌ 请提供提示模板名称"} + + arguments = None + if arguments_str: + try: + arguments = json.loads(arguments_str) + except json.JSONDecodeError: + return {"name": self.name, "content": "❌ 参数格式错误，请使用 JSON 对象格式"} + + result = await mcp_manager.get_prompt(prompt_name, arguments, server_name) + + if result.success: + return {"name": self.name, "content": result.content} + else: + return {"name": self.name, "content": f"❌ 获取提示模板失败: {result.error}"} + + async def direct_execute(self, **function_args) -> Dict[str, Any]: + return await self.execute(function_args) + + +# ============================================================================ +# v1.8.0: 工具链代理工具 +# ============================================================================ + +class ToolChainProxyBase(BaseTool): + """工具链代理基类""" + + name: str = "" + description: str = "" + parameters: List[Tuple[str, ToolParamType, str, bool, Optional[List[str]]]] = [] + available_for_llm: bool = True + + _chain_name: str = "" + + async def execute(self, function_args: Dict[str, Any]) -> Dict[str, Any]: + """执行工具链""" + # 移除内部标记 + args = {k: v for k, v in function_args.items() if k != "llm_called"} + + logger.debug(f"执行工具链 {self._chain_name}，参数: {args}") + + result = await tool_chain_manager.execute_chain(self._chain_name, args) + + if result.success: + # 构建输出 + output_parts = [] + output_parts.append(result.final_output) + + # 可选：添加执行摘要 + # output_parts.append(f"\n\n---\n执行摘要:\n{result.to_summary()}") + + return {"name": self.name, "content": "\n".join(output_parts)} + else: + error_msg = f"⚠️ 工具链执行失败: {result.error}" + if result.step_results: + error_msg += f"\n\n执行详情:\n{result.to_summary()}" + return {"name": self.name, "content": error_msg} + + async def direct_execute(self, **function_args) -> Dict[str, Any]: + return await self.execute(function_args) + + +def create_chain_tool_class(chain: ToolChainDefinition) -> Type[ToolChainProxyBase]: + """根据工具链定义动态创建工具类""" + # 构建参数列表 + parameters = [] + for param_name, param_desc in chain.input_params.items(): + parameters.append((param_name, ToolParamType.STRING, param_desc, True, None)) + + # 生成类名和工具名 + class_name = f"ToolChain_{chain.name}".replace("-", "_").replace(".", "_") + tool_name = f"chain_{chain.name}".replace("-", "_").replace(".", "_") + + # 构建描述 + description = chain.description + if chain.steps: + step_names = [s.tool_name.split("_")[-1] for s in chain.steps[:3]] + description += f" (执行流程: {' → '.join(step_names)}{'...' if len(chain.steps) > 3 else ''})" + + tool_class = type( + class_name, + (ToolChainProxyBase,), + { + "name": tool_name, + "description": description, + "parameters": parameters, + "available_for_llm": True, + "_chain_name": chain.name, + } + ) + + return tool_class + + +class ToolChainRegistry: + """工具链注册表""" + + def __init__(self): + self._tool_classes: Dict[str, Type[ToolChainProxyBase]] = {} + self._tool_infos: Dict[str, ToolInfo] = {} + + def register_chain(self, chain: ToolChainDefinition) -> Tuple[ToolInfo, Type[ToolChainProxyBase]]: + """注册工具链为组合工具""" + tool_class = create_chain_tool_class(chain) + + self._tool_classes[chain.name] = tool_class + + info = ToolInfo( + name=tool_class.name, + tool_description=tool_class.description, + enabled=True, + tool_parameters=tool_class.parameters, + component_type=ComponentType.TOOL, + ) + self._tool_infos[chain.name] = info + + return info, tool_class + + def unregister_chain(self, chain_name: str) -> bool: + """注销工具链""" + if chain_name in self._tool_classes: + del self._tool_classes[chain_name] + del self._tool_infos[chain_name] + return True + return False + + def get_all_components(self) -> List[Tuple[ComponentInfo, Type]]: + """获取所有工具链组件""" + return [(self._tool_infos[key], self._tool_classes[key]) for key in self._tool_classes.keys()] + + def clear(self) -> None: + """清空所有注册""" + self._tool_classes.clear() + self._tool_infos.clear() + + +# 全局工具链注册表 +tool_chain_registry = ToolChainRegistry() + + +class MCPStatusTool(BaseTool): + """MCP 状态查询工具""" + + name = "mcp_status" + description = "查询 MCP 桥接插件的状态，包括服务器连接状态、可用工具列表、工具链列表、资源列表、提示模板列表、调用统计、追踪记录等信息" + parameters = [ + ("query_type", ToolParamType.STRING, "查询类型", False, ["status", "tools", "chains", "resources", "prompts", "stats", "trace", "cache", "all"]), + ("server_name", ToolParamType.STRING, "指定服务器名称（可选）", False, None), + ] + available_for_llm = True + + async def execute(self, function_args: Dict[str, Any]) -> Dict[str, Any]: + query_type = function_args.get("query_type", "status") + server_name = function_args.get("server_name") + + result_parts = [] + + if query_type in ("status", "all"): + result_parts.append(self._format_status(server_name)) + + if query_type in ("tools", "all"): + result_parts.append(self._format_tools(server_name)) + + if query_type in ("chains", "all"): + result_parts.append(self._format_chains()) + + if query_type in ("resources", "all"): + result_parts.append(self._format_resources(server_name)) + + if query_type in ("prompts", "all"): + result_parts.append(self._format_prompts(server_name)) + + if query_type in ("stats", "all"): + result_parts.append(self._format_stats(server_name)) + + # v1.4.0: 追踪记录 + if query_type in ("trace",): + result_parts.append(self._format_trace()) + + # v1.4.0: 缓存状态 + if query_type in ("cache",): + result_parts.append(self._format_cache()) + + return { + "name": self.name, + "content": "\n\n".join(result_parts) if result_parts else "未知的查询类型" + } + + def _format_status(self, server_name: Optional[str] = None) -> str: + status = mcp_manager.get_status() + lines = ["📊 MCP 桥接插件状态"] + lines.append(f" 总服务器数: {status['total_servers']}") + lines.append(f" 已连接: {status['connected_servers']}") + lines.append(f" 已断开: {status['disconnected_servers']}") + lines.append(f" 可用工具数: {status['total_tools']}") + lines.append(f" 心跳检测: {'运行中' if status['heartbeat_running'] else '已停止'}") + + lines.append("\n🔌 服务器详情:") + for name, info in status['servers'].items(): + if server_name and name != server_name: + continue + status_icon = "✅" if info['connected'] else "❌" + enabled_text = "" if info['enabled'] else " (已禁用)" + lines.append(f" {status_icon} {name}{enabled_text}") + lines.append(f" 传输: {info['transport']}, 工具数: {info['tools_count']}") + if info['consecutive_failures'] > 0: + lines.append(f" ⚠️ 连续失败: {info['consecutive_failures']} 次") + + return "\n".join(lines) + + def _format_tools(self, server_name: Optional[str] = None) -> str: + tools = mcp_manager.all_tools + lines = ["🔧 可用 MCP 工具"] + + by_server: Dict[str, List[str]] = {} + for tool_key, (tool_info, _) in tools.items(): + if server_name and tool_info.server_name != server_name: + continue + if tool_info.server_name not in by_server: + by_server[tool_info.server_name] = [] + by_server[tool_info.server_name].append(f" • {tool_key}: {tool_info.description[:50]}...") + + for srv_name, tool_list in by_server.items(): + lines.append(f"\n📦 {srv_name} ({len(tool_list)} 个工具):") + lines.extend(tool_list) + + if not by_server: + lines.append(" (无可用工具)") + + return "\n".join(lines) + + def _format_stats(self, server_name: Optional[str] = None) -> str: + stats = mcp_manager.get_all_stats() + lines = ["📈 调用统计"] + + g = stats['global'] + lines.append(f" 总调用次数: {g['total_tool_calls']}") + lines.append(f" 成功: {g['successful_calls']}, 失败: {g['failed_calls']}") + if g['total_tool_calls'] > 0: + success_rate = (g['successful_calls'] / g['total_tool_calls']) * 100 + lines.append(f" 成功率: {success_rate:.1f}%") + lines.append(f" 运行时间: {g['uptime_seconds']:.0f} 秒") + + return "\n".join(lines) + + def _format_resources(self, server_name: Optional[str] = None) -> str: + resources = mcp_manager.all_resources + if not resources: + return "📦 当前没有可用的 MCP 资源" + + lines = ["📦 可用 MCP 资源"] + by_server: Dict[str, List[MCPResourceInfo]] = {} + for key, (resource_info, _) in resources.items(): + if server_name and resource_info.server_name != server_name: + continue + if resource_info.server_name not in by_server: + by_server[resource_info.server_name] = [] + by_server[resource_info.server_name].append(resource_info) + + for srv_name, resource_list in by_server.items(): + lines.append(f"\n🔌 {srv_name} ({len(resource_list)} 个资源):") + for res in resource_list: + lines.append(f" • {res.name}: {res.uri}") + + return "\n".join(lines) + + def _format_prompts(self, server_name: Optional[str] = None) -> str: + prompts = mcp_manager.all_prompts + if not prompts: + return "📝 当前没有可用的 MCP 提示模板" + + lines = ["📝 可用 MCP 提示模板"] + by_server: Dict[str, List[MCPPromptInfo]] = {} + for key, (prompt_info, _) in prompts.items(): + if server_name and prompt_info.server_name != server_name: + continue + if prompt_info.server_name not in by_server: + by_server[prompt_info.server_name] = [] + by_server[prompt_info.server_name].append(prompt_info) + + for srv_name, prompt_list in by_server.items(): + lines.append(f"\n🔌 {srv_name} ({len(prompt_list)} 个模板):") + for prompt in prompt_list: + lines.append(f" • {prompt.name}") + + return "\n".join(lines) + + def _format_trace(self) -> str: + """v1.4.0: 格式化追踪记录""" + records = tool_call_tracer.get_recent(10) + if not records: + return "🔍 暂无调用追踪记录" + + lines = ["🔍 最近调用追踪记录"] + for r in reversed(records): + status = "✅" if r.success else "❌" + cache = "📦" if r.cache_hit else "" + post = "🔄" if r.post_processed else "" + lines.append(f" {status}{cache}{post} {r.tool_name} ({r.duration_ms:.0f}ms)") + if r.error: + lines.append(f" 错误: {r.error[:50]}") + + return "\n".join(lines) + + def _format_cache(self) -> str: + """v1.4.0: 格式化缓存状态""" + stats = tool_call_cache.get_stats() + lines = ["🗄️ 缓存状态"] + lines.append(f" 启用: {'是' if stats['enabled'] else '否'}") + lines.append(f" 条目数: {stats['entries']}/{stats['max_entries']}") + lines.append(f" TTL: {stats['ttl']}秒") + lines.append(f" 命中: {stats['hits']}, 未命中: {stats['misses']}") + lines.append(f" 命中率: {stats['hit_rate']}") + return "\n".join(lines) + + def _format_chains(self) -> str: + """v1.8.0: 格式化工具链列表""" + chains = tool_chain_manager.get_all_chains() + if not chains: + return "🔗 当前没有配置工具链" + + lines = ["🔗 工具链列表"] + for name, chain in chains.items(): + status = "✅" if chain.enabled else "❌" + lines.append(f"\n{status} {name}") + lines.append(f" 描述: {chain.description[:50]}...") + lines.append(f" 步骤: {len(chain.steps)} 个") + for i, step in enumerate(chain.steps[:3]): + lines.append(f" {i+1}. {step.tool_name}") + if len(chain.steps) > 3: + lines.append(f" ... 还有 {len(chain.steps) - 3} 个步骤") + if chain.input_params: + params = ", ".join(chain.input_params.keys()) + lines.append(f" 参数: {params}") + + return "\n".join(lines) + + async def direct_execute(self, **function_args) -> Dict[str, Any]: + return await self.execute(function_args) + + +# ============================================================================ +# 命令处理 +# ============================================================================ + +class MCPStatusCommand(BaseCommand): + """MCP 状态查询命令 - 通过 /mcp 命令查看服务器状态""" + + command_name = "mcp_status_command" + command_description = "查看 MCP 服务器连接状态和统计信息" + command_pattern = r"^[/／]mcp(?:\s+(?Pstatus|tools|stats|reconnect|trace|cache|perm|export|search|chain))?(?:\s+(?P.+))?$" + + async def execute(self) -> Tuple[bool, Optional[str], bool]: + """执行命令""" + subcommand = self.matched_groups.get("subcommand", "status") or "status" + arg = self.matched_groups.get("arg") + + if subcommand == "reconnect": + return await self._handle_reconnect(arg) + + # v1.4.0: 追踪命令 + if subcommand == "trace": + return await self._handle_trace(arg) + + # v1.4.0: 缓存命令 + if subcommand == "cache": + return await self._handle_cache(arg) + + # v1.4.0: 权限命令 + if subcommand == "perm": + return await self._handle_perm(arg) + + # v1.6.0: 导出命令 + if subcommand == "export": + return await self._handle_export(arg) + + # v1.7.0: 工具搜索命令 + if subcommand == "search": + return await self._handle_search(arg) + + # v1.8.0: 工具链命令 + if subcommand == "chain": + return await self._handle_chain(arg) + + result = self._format_output(subcommand, arg) + await self.send_text(result) + return (True, None, True) + + def _find_similar_servers(self, name: str, max_results: int = 3) -> List[str]: + """查找相似的服务器名称""" + name_lower = name.lower() + all_servers = list(mcp_manager._clients.keys()) + + # 简单的相似度匹配：包含关系或前缀匹配 + similar = [] + for srv in all_servers: + srv_lower = srv.lower() + if name_lower in srv_lower or srv_lower in name_lower: + similar.append(srv) + elif srv_lower.startswith(name_lower[:3]) if len(name_lower) >= 3 else False: + similar.append(srv) + + return similar[:max_results] + + async def _handle_reconnect(self, server_name: Optional[str] = None) -> Tuple[bool, Optional[str], bool]: + """处理重连请求""" + if server_name: + if server_name not in mcp_manager._clients: + # 提示相似的服务器名 + similar = self._find_similar_servers(server_name) + msg = f"❌ 服务器 '{server_name}' 不存在" + if similar: + msg += f"\n💡 你是不是想找: {', '.join(similar)}" + await self.send_text(msg) + return (True, None, True) + + await self.send_text(f"🔄 正在重连服务器 {server_name}...") + success = await mcp_manager.reconnect_server(server_name) + if success: + await self.send_text(f"✅ 服务器 {server_name} 重连成功") + else: + await self.send_text(f"❌ 服务器 {server_name} 重连失败") + else: + disconnected = mcp_manager.disconnected_servers + if not disconnected: + await self.send_text("✅ 所有服务器都已连接") + return (True, None, True) + + await self.send_text(f"🔄 正在重连 {len(disconnected)} 个断开的服务器...") + for srv in disconnected: + success = await mcp_manager.reconnect_server(srv) + status = "✅" if success else "❌" + await self.send_text(f"{status} {srv}") + + return (True, None, True) + + async def _handle_trace(self, arg: Optional[str] = None) -> Tuple[bool, Optional[str], bool]: + """v1.4.0: 处理追踪命令""" + if arg and arg.isdigit(): + # /mcp trace 20 - 最近 N 条 + n = int(arg) + records = tool_call_tracer.get_recent(n) + elif arg: + # /mcp trace - 特定工具 + records = tool_call_tracer.get_by_tool(arg) + else: + # /mcp trace - 最近 10 条 + records = tool_call_tracer.get_recent(10) + + if not records: + await self.send_text("🔍 暂无调用追踪记录\n\n用法: /mcp trace [数量|工具名]") + return (True, None, True) + + lines = [f"🔍 调用追踪记录 ({len(records)} 条)"] + lines.append("-" * 30) + for i, r in enumerate(reversed(records)): + status_icon = "✅" if r.success else "❌" + cache_tag = " [缓存]" if r.cache_hit else "" + post_tag = " [后处理]" if r.post_processed else "" + ts = time.strftime("%H:%M:%S", time.localtime(r.timestamp)) + lines.append(f"{status_icon} [{ts}] {r.tool_name}") + lines.append(f" {r.duration_ms:.0f}ms | {r.server_name}{cache_tag}{post_tag}") + if r.error: + lines.append(f" 错误: {r.error[:50]}") + if i < len(records) - 1: + lines.append("") + + await self.send_text("\n".join(lines)) + return (True, None, True) + + async def _handle_cache(self, arg: Optional[str] = None) -> Tuple[bool, Optional[str], bool]: + """v1.4.0: 处理缓存命令""" + if arg == "clear": + tool_call_cache.clear() + await self.send_text("✅ 缓存已清空") + return (True, None, True) + + stats = tool_call_cache.get_stats() + lines = ["🗄️ 缓存状态"] + lines.append(f"├ 启用: {'是' if stats['enabled'] else '否'}") + lines.append(f"├ 条目: {stats['entries']}/{stats['max_entries']}") + lines.append(f"├ TTL: {stats['ttl']}秒") + lines.append(f"├ 命中: {stats['hits']}") + lines.append(f"├ 未命中: {stats['misses']}") + lines.append(f"└ 命中率: {stats['hit_rate']}") + + await self.send_text("\n".join(lines)) + return (True, None, True) + + async def _handle_perm(self, arg: Optional[str] = None) -> Tuple[bool, Optional[str], bool]: + """v1.4.0: 处理权限命令""" + global _plugin_instance + + if _plugin_instance is None: + await self.send_text("❌ 插件未初始化") + return (True, None, True) + + perm_config = _plugin_instance.config.get("permissions", {}) + enabled = perm_config.get("perm_enabled", False) + default_mode = perm_config.get("perm_default_mode", "allow_all") + + if arg: + # 查看特定工具的权限 + rules = permission_checker.get_rules_for_tool(arg) + if not rules: + await self.send_text(f"🔐 工具 {arg} 无特定权限规则\n默认模式: {default_mode}") + else: + lines = [f"🔐 工具 {arg} 的权限规则:"] + for r in rules: + lines.append(f" • 模式: {r.get('mode', 'default')}") + if r.get("allowed"): + lines.append(f" 允许: {', '.join(r['allowed'][:3])}...") + if r.get("denied"): + lines.append(f" 拒绝: {', '.join(r['denied'][:3])}...") + await self.send_text("\n".join(lines)) + else: + # 查看权限配置概览 + lines = ["🔐 权限控制配置"] + lines.append(f"├ 启用: {'是' if enabled else '否'}") + lines.append(f"├ 默认模式: {default_mode}") + # 快捷配置 + deny_count = len(permission_checker._quick_deny_groups) + allow_count = len(permission_checker._quick_allow_users) + if deny_count > 0: + lines.append(f"├ 禁用群: {deny_count} 个") + if allow_count > 0: + lines.append(f"├ 管理员白名单: {allow_count} 人") + lines.append(f"└ 高级规则: {len(permission_checker._rules)} 条") + await self.send_text("\n".join(lines)) + + return (True, None, True) + + async def _handle_export(self, format_type: Optional[str] = None) -> Tuple[bool, Optional[str], bool]: + """v1.6.0: 处理导出命令""" + global _plugin_instance + + if _plugin_instance is None: + await self.send_text("❌ 插件未初始化") + return (True, None, True) + + servers_section = _plugin_instance.config.get("servers", {}) + if not isinstance(servers_section, dict): + servers_section = {} + + claude_json = str(servers_section.get("claude_config_json", "") or "") + if not claude_json.strip(): + legacy_list = str(servers_section.get("list", "") or "") + claude_json = legacy_servers_list_to_claude_config(legacy_list) or "" + + if not claude_json.strip(): + await self.send_text("📤 当前没有配置任何服务器") + return (True, None, True) + + try: + pretty = json.dumps(json.loads(claude_json), ensure_ascii=False, indent=2) + except Exception: + pretty = claude_json + + lines = ["📤 导出为 Claude Desktop 格式（mcpServers）:"] + if format_type and format_type.strip() and format_type.strip().lower() != "claude": + lines.append("（v2.0 已精简为仅 Claude 格式，忽略其他格式参数）") + lines.append("") + lines.append(pretty) + await self.send_text("\n".join(lines)) + + return (True, None, True) + + async def _handle_search(self, query: Optional[str] = None) -> Tuple[bool, Optional[str], bool]: + """v1.7.0: 处理工具搜索命令""" + if not query or not query.strip(): + # 显示使用帮助 + help_text = """🔍 工具搜索 + +用法: /mcp search <关键词> + +示例: + /mcp search time 搜索包含 time 的工具 + /mcp search fetch 搜索包含 fetch 的工具 + /mcp search * 列出所有工具 + +支持模糊匹配工具名称和描述""" + await self.send_text(help_text) + return (True, None, True) + + query = query.strip().lower() + tools = mcp_manager.all_tools + + if not tools: + await self.send_text("🔍 当前没有可用的 MCP 工具") + return (True, None, True) + + # 搜索匹配的工具 + matched = [] + for tool_key, (tool_info, client) in tools.items(): + tool_name = tool_key.lower() + tool_desc = (tool_info.description or "").lower() + + # * 表示列出所有 + if query == "*": + matched.append((tool_key, tool_info, client)) + elif query in tool_name or query in tool_desc: + matched.append((tool_key, tool_info, client)) + + if not matched: + await self.send_text(f"🔍 未找到匹配 '{query}' 的工具") + return (True, None, True) + + # 按服务器分组显示 + by_server: Dict[str, List[Tuple[str, Any]]] = {} + for tool_key, tool_info, client in matched: + server_name = tool_info.server_name + if server_name not in by_server: + by_server[server_name] = [] + by_server[server_name].append((tool_key, tool_info)) + + # 如果只有一个服务器或结果较少，显示全部；否则折叠 + single_server = len(by_server) == 1 + lines = [f"🔍 搜索结果: {len(matched)} 个工具匹配 '{query}'"] + + for srv_name, tool_list in by_server.items(): + lines.append(f"\n📦 {srv_name} ({len(tool_list)} 个):") + + # 单服务器或结果少于 15 个时显示全部 + show_all = single_server or len(matched) <= 15 + display_limit = len(tool_list) if show_all else 5 + + for tool_key, tool_info in tool_list[:display_limit]: + desc = tool_info.description[:40] + "..." if len(tool_info.description) > 40 else tool_info.description + lines.append(f" • {tool_key}") + lines.append(f" {desc}") + if len(tool_list) > display_limit: + lines.append(f" ... 还有 {len(tool_list) - display_limit} 个，用 /mcp search {query} {srv_name} 筛选") + + await self.send_text("\n".join(lines)) + return (True, None, True) + + async def _handle_chain(self, arg: Optional[str] = None) -> Tuple[bool, Optional[str], bool]: + """v1.8.0: 处理工具链命令""" + if not arg or not arg.strip(): + # 显示工具链列表和帮助 + chains = tool_chain_manager.get_all_chains() + + lines = ["🔗 工具链管理"] + lines.append("") + + if chains: + lines.append(f"已配置 {len(chains)} 个工具链:") + for name, chain in chains.items(): + status = "✅" if chain.enabled else "❌" + steps_count = len(chain.steps) + lines.append(f" {status} {name} ({steps_count} 步)") + else: + lines.append("当前没有配置工具链") + + lines.append("") + lines.append("命令:") + lines.append(" /mcp chain list 查看所有工具链") + lines.append(" /mcp chain <名称> 查看工具链详情") + lines.append(" /mcp chain test <名称> <参数JSON> 测试执行") + lines.append(" /mcp chain reload 重新加载配置") + lines.append("") + lines.append("💡 在 WebUI「工具链」配置区编辑工具链") + + await self.send_text("\n".join(lines)) + return (True, None, True) + + parts = arg.strip().split(maxsplit=2) + sub_action = parts[0].lower() + + if sub_action == "list": + # 列出所有工具链 + chains = tool_chain_manager.get_all_chains() + if not chains: + await self.send_text("🔗 当前没有配置工具链") + return (True, None, True) + + lines = [f"🔗 工具链列表 ({len(chains)} 个)"] + for name, chain in chains.items(): + status = "✅" if chain.enabled else "❌" + lines.append(f"\n{status} {name}") + lines.append(f" {chain.description[:60]}...") + lines.append(f" 步骤: {' → '.join([s.tool_name.split('_')[-1] for s in chain.steps[:4]])}") + if chain.input_params: + lines.append(f" 参数: {', '.join(chain.input_params.keys())}") + + await self.send_text("\n".join(lines)) + return (True, None, True) + + elif sub_action == "reload": + # 重新加载工具链配置 + global _plugin_instance + if _plugin_instance: + _plugin_instance._load_tool_chains() + chains = tool_chain_manager.get_all_chains() + from src.plugin_system.core.component_registry import component_registry + registered = 0 + for name, chain in tool_chain_manager.get_enabled_chains().items(): + tool_name = f"chain_{name}".replace("-", "_").replace(".", "_") + if component_registry.get_component_info(tool_name, ComponentType.TOOL): + registered += 1 + lines = [f"✅ 已重新加载工具链配置"] + lines.append(f"📋 配置数: {len(chains)} 个") + lines.append(f"🔧 已注册: {registered} 个（可被 LLM 调用）") + if chains: + lines.append("") + lines.append("工具链列表:") + for name, chain in chains.items(): + status = "✅" if chain.enabled else "❌" + lines.append(f" {status} chain_{name}") + await self.send_text("\n".join(lines)) + else: + await self.send_text("❌ 插件未初始化") + return (True, None, True) + + elif sub_action == "test" and len(parts) >= 2: + # 测试执行工具链 + chain_name = parts[1] + args_json = parts[2] if len(parts) > 2 else "{}" + + chain = tool_chain_manager.get_chain(chain_name) + if not chain: + await self.send_text(f"❌ 工具链 '{chain_name}' 不存在") + return (True, None, True) + + try: + input_args = json.loads(args_json) + except json.JSONDecodeError: + await self.send_text("❌ 参数 JSON 格式错误") + return (True, None, True) + + await self.send_text(f"🔄 正在执行工具链 {chain_name}...") + + result = await tool_chain_manager.execute_chain(chain_name, input_args) + + lines = [] + if result.success: + lines.append(f"✅ 工具链执行成功 ({result.total_duration_ms:.0f}ms)") + lines.append("") + lines.append("执行详情:") + lines.append(result.to_summary()) + lines.append("") + lines.append("最终输出:") + output_preview = result.final_output[:500] + if len(result.final_output) > 500: + output_preview += "..." + lines.append(output_preview) + else: + lines.append(f"❌ 工具链执行失败") + lines.append(f"错误: {result.error}") + if result.step_results: + lines.append("") + lines.append("执行详情:") + lines.append(result.to_summary()) + + await self.send_text("\n".join(lines)) + return (True, None, True) + + else: + # 查看特定工具链详情 + chain_name = sub_action + chain = tool_chain_manager.get_chain(chain_name) + + if not chain: + # 尝试模糊匹配 + all_chains = tool_chain_manager.get_all_chains() + similar = [n for n in all_chains.keys() if chain_name.lower() in n.lower()] + msg = f"❌ 工具链 '{chain_name}' 不存在" + if similar: + msg += f"\n💡 你是不是想找: {', '.join(similar[:3])}" + await self.send_text(msg) + return (True, None, True) + + lines = [f"🔗 工具链: {chain.name}"] + lines.append(f"状态: {'✅ 启用' if chain.enabled else '❌ 禁用'}") + lines.append(f"描述: {chain.description}") + lines.append("") + + if chain.input_params: + lines.append("📥 输入参数:") + for param, desc in chain.input_params.items(): + lines.append(f" • {param}: {desc}") + lines.append("") + + lines.append(f"📋 执行步骤 ({len(chain.steps)} 个):") + for i, step in enumerate(chain.steps): + optional_tag = " (可选)" if step.optional else "" + lines.append(f" {i+1}. {step.tool_name}{optional_tag}") + if step.description: + lines.append(f" {step.description}") + if step.output_key: + lines.append(f" 输出键: {step.output_key}") + if step.args_template: + args_preview = json.dumps(step.args_template, ensure_ascii=False)[:60] + lines.append(f" 参数: {args_preview}...") + + lines.append("") + lines.append(f"💡 测试: /mcp chain test {chain.name} " + '{"参数": "值"}') + + await self.send_text("\n".join(lines)) + return (True, None, True) + + def _format_output(self, subcommand: str, server_name: str = None) -> str: + """格式化输出""" + status = mcp_manager.get_status() + stats = mcp_manager.get_all_stats() + lines = [] + + if subcommand in ("status", "all"): + lines.append("📊 MCP 桥接插件状态") + lines.append(f"├ 服务器: {status['connected_servers']}/{status['total_servers']} 已连接") + lines.append(f"├ 工具数: {status['total_tools']}") + lines.append(f"└ 心跳: {'运行中' if status['heartbeat_running'] else '已停止'}") + + if status["servers"]: + lines.append("\n🔌 服务器列表:") + for name, info in status["servers"].items(): + if server_name and name != server_name: + continue + icon = "✅" if info["connected"] else "❌" + enabled = "" if info["enabled"] else " (禁用)" + lines.append(f" {icon} {name}{enabled}") + lines.append(f" {info['transport']} | {info['tools_count']} 工具") + # 显示断路器状态 + cb = info.get("circuit_breaker", {}) + cb_state = cb.get("state", "closed") + if cb_state == "open": + lines.append(f" ⚡ 断路器熔断中") + elif cb_state == "half_open": + lines.append(f" ⚡ 断路器试探中") + if info["consecutive_failures"] > 0: + lines.append(f" ⚠️ 连续失败 {info['consecutive_failures']} 次") + + if subcommand in ("tools", "all"): + tools = mcp_manager.all_tools + if tools: + lines.append("\n🔧 可用工具:") + by_server = {} + for key, (info, _) in tools.items(): + if server_name and info.server_name != server_name: + continue + by_server.setdefault(info.server_name, []).append(info.name) + + # 如果指定了服务器名，显示全部工具；否则折叠显示 + show_all = server_name is not None + + for srv, tool_list in by_server.items(): + lines.append(f" 📦 {srv} ({len(tool_list)})") + if show_all: + # 指定服务器时显示全部 + for t in tool_list: + lines.append(f" • {t}") + else: + # 未指定时折叠显示 + for t in tool_list[:5]: + lines.append(f" • {t}") + if len(tool_list) > 5: + lines.append(f" ... 还有 {len(tool_list) - 5} 个，用 /mcp tools {srv} 查看全部") + + if subcommand in ("stats", "all"): + g = stats["global"] + lines.append("\n📈 调用统计:") + lines.append(f" 总调用: {g['total_tool_calls']}") + if g["total_tool_calls"] > 0: + rate = (g["successful_calls"] / g["total_tool_calls"]) * 100 + lines.append(f" 成功率: {rate:.1f}%") + lines.append(f" 运行: {g['uptime_seconds']:.0f}秒") + + if not lines: + lines.append("📖 MCP 桥接插件命令帮助") + lines.append("") + lines.append("状态查询:") + lines.append(" /mcp 查看连接状态") + lines.append(" /mcp tools 查看所有工具") + lines.append(" /mcp tools <服务器> 查看指定服务器工具") + lines.append(" /mcp stats 查看调用统计") + lines.append("") + lines.append("工具搜索:") + lines.append(" /mcp search <关键词> 搜索工具") + lines.append(" /mcp search * 列出所有工具") + lines.append("") + lines.append("服务器管理:") + lines.append(" /mcp reconnect 重连断开的服务器") + lines.append(" /mcp reconnect <名称> 重连指定服务器") + lines.append("") + lines.append("服务器配置（Claude）:") + lines.append(" /mcp import 合并 Claude mcpServers 配置") + lines.append(" /mcp export 导出当前 mcpServers 配置") + lines.append("") + lines.append("工具链:") + lines.append(" /mcp chain 查看工具链列表") + lines.append(" /mcp chain <名称> 查看工具链详情") + lines.append(" /mcp chain test <名称> <参数> 测试执行") + lines.append("") + lines.append("其他:") + lines.append(" /mcp trace 查看调用追踪") + lines.append(" /mcp cache 查看缓存状态") + lines.append(" /mcp perm 查看权限配置") + + return "\n".join(lines) + + +class MCPImportCommand(BaseCommand): + """v1.6.0: MCP 配置导入命令 - 支持从 Claude Desktop 格式导入""" + + command_name = "mcp_import_command" + command_description = "从 Claude Desktop 或其他格式导入 MCP 服务器配置" + # 匹配 /mcp import 后面的所有内容（包括多行 JSON） + command_pattern = r"^[/／]mcp\s+import(?:\s+(?P.+))?$" + + async def execute(self) -> Tuple[bool, Optional[str], bool]: + """执行导入命令""" + global _plugin_instance + + if _plugin_instance is None: + await self.send_text("❌ 插件未初始化") + return (True, None, True) + + content = self.matched_groups.get("content", "") + + if not content or not content.strip(): + # 显示使用帮助 + help_text = """📥 MCP 配置导入 + +用法: /mcp import + +支持的格式: +• Claude Desktop 格式 (mcpServers 对象) +• 兼容旧版：MaiBot servers 列表数组（将自动迁移为 mcpServers） + +示例: +/mcp import {"mcpServers":{"time":{"command":"uvx","args":["mcp-server-time"]}}} + +/mcp import {"mcpServers":{"api":{"url":"https://example.com/mcp","transport":"sse"}}}""" + await self.send_text(help_text) + return (True, None, True) + + raw_text = content.strip() + + # 解析输入：支持 Claude mcpServers 或旧版 servers 列表数组 + try: + data = json.loads(raw_text) + except json.JSONDecodeError as e: + await self.send_text(f"❌ JSON 解析失败: {e}") + return (True, None, True) + + if isinstance(data, list): + migrated = legacy_servers_list_to_claude_config(raw_text) + if not migrated: + await self.send_text("❌ 旧版 servers 列表解析失败，无法迁移") + return (True, None, True) + data = json.loads(migrated) + + if not isinstance(data, dict): + await self.send_text("❌ 配置必须是 JSON 对象（包含 mcpServers）") + return (True, None, True) + + incoming_mapping = data.get("mcpServers", data) + if not isinstance(incoming_mapping, dict): + await self.send_text("❌ mcpServers 必须是 JSON 对象") + return (True, None, True) + + # 校验输入配置 + try: + parse_claude_mcp_config(json.dumps({"mcpServers": incoming_mapping}, ensure_ascii=False)) + except ClaudeConfigError as e: + await self.send_text(f"❌ 配置校验失败: {e}") + return (True, None, True) + + servers_section = _plugin_instance.config.get("servers", {}) + if not isinstance(servers_section, dict): + servers_section = {} + + existing_json = str(servers_section.get("claude_config_json", "") or "") + if not existing_json.strip(): + legacy_list = str(servers_section.get("list", "") or "") + existing_json = legacy_servers_list_to_claude_config(legacy_list) or "" + + existing_mapping: Dict[str, Any] = {} + if existing_json.strip(): + try: + parsed = json.loads(existing_json) + mapping = parsed.get("mcpServers", parsed) + if isinstance(mapping, dict): + existing_mapping = mapping + except Exception: + existing_mapping = {} + + added: List[str] = [] + skipped: List[str] = [] + + for name, conf in incoming_mapping.items(): + if name in existing_mapping: + skipped.append(str(name)) + continue + existing_mapping[str(name)] = conf + added.append(str(name)) + + if "servers" not in _plugin_instance.config: + _plugin_instance.config["servers"] = {} + + _plugin_instance.config["servers"]["claude_config_json"] = json.dumps( + {"mcpServers": existing_mapping}, ensure_ascii=False, indent=2 + ) + + # 持久化到配置文件（使用插件基类的写入逻辑） + try: + config_path = Path(_plugin_instance.plugin_dir) / _plugin_instance.config_file_name + _plugin_instance._save_config_to_file(_plugin_instance.config, str(config_path)) + except Exception as e: + logger.warning(f"保存配置文件失败: {e}") + + lines = [] + if added: + lines.append(f"✅ 成功导入 {len(added)} 个服务器:") + for n in added[:20]: + lines.append(f" • {n}") + if len(added) > 20: + lines.append(f" ... 还有 {len(added) - 20} 个") + else: + lines.append("⚠️ 没有新服务器可导入") + + if skipped: + lines.append(f"\n⏭️ 跳过 {len(skipped)} 个已存在的服务器") + + lines.append("\n💡 发送 /mcp reconnect 使配置生效") + + await self.send_text("\n".join(lines)) + return (True, None, True) + + +# ============================================================================ +# 事件处理器 +# ============================================================================ + +class MCPStartupHandler(BaseEventHandler): + """MCP 启动事件处理器""" + + event_type = EventType.ON_START + handler_name = "mcp_startup_handler" + handler_description = "MCP 桥接插件启动处理器" + weight = 0 + intercept_message = False + + async def execute(self, message: Optional[Any]) -> Tuple[bool, bool, Optional[str], None, None]: + """处理启动事件""" + global _plugin_instance + + if _plugin_instance is None: + logger.warning("MCP 桥接插件实例未初始化") + return (False, True, None, None, None) + + logger.info("MCP 桥接插件收到 ON_START 事件，开始连接 MCP 服务器...") + await _plugin_instance._async_connect_servers() + + await mcp_manager.start_heartbeat() + + return (True, True, None, None, None) + + +class MCPStopHandler(BaseEventHandler): + """MCP 停止事件处理器""" + + event_type = EventType.ON_STOP + handler_name = "mcp_stop_handler" + handler_description = "MCP 桥接插件停止处理器" + weight = 0 + intercept_message = False + + async def execute(self, message: Optional[Any]) -> Tuple[bool, bool, Optional[str], None, None]: + """处理停止事件""" + global _plugin_instance + + logger.info("MCP 桥接插件收到 ON_STOP 事件，正在关闭...") + + if _plugin_instance is not None: + await _plugin_instance._stop_status_refresher() + + await mcp_manager.shutdown() + mcp_tool_registry.clear() + + logger.info("MCP 桥接插件已关闭所有连接") + return (True, True, None, None, None) + + +# ============================================================================ +# 主插件类 +# ============================================================================ + +@register_plugin +class MCPBridgePlugin(BasePlugin): + """MCP 桥接插件 v2.0.0 - 将 MCP 服务器的工具桥接到 MaiBot""" + + plugin_name: str = "mcp_bridge_plugin" + enable_plugin: bool = False # 默认禁用，用户需在 WebUI 手动启用 + dependencies: List[str] = [] + python_dependencies: List[str] = ["mcp"] + config_file_name: str = "config.toml" + + config_section_descriptions = { + "guide": section_meta("📖 快速入门", order=1), + "plugin": section_meta("🔘 插件开关", order=2), + "servers": section_meta("🔌 MCP Servers（Claude）", order=3), + "tool_chains": section_meta("🔗 Workflow（硬流程/工具链）", order=4), + "react": section_meta("🔄 ReAct（软流程）", collapsed=True, order=5), + "status": section_meta("📊 运行状态", order=10), + "tools": section_meta("🔧 工具管理", collapsed=True, order=20), + "permissions": section_meta("🔐 权限控制", collapsed=True, order=21), + "settings": section_meta("⚙️ 高级设置", collapsed=True, order=30), + } + + config_schema: dict = { + # 新手引导区（只读） + "guide": { + "quick_start": ConfigField( + type=str, + default="1. 获取 MCP 服务器 2. 在「MCP Servers（Claude）」粘贴 mcpServers 配置 3. 保存后发送 /mcp reconnect 4. （可选）在「Workflow/ ReAct」配置流程", + description="三步开始使用", + label="🚀 快速入门", + disabled=True, + order=1, + ), + "mcp_sources": ConfigField( + type=str, + default="https://modelscope.cn/mcp (魔搭·推荐) | https://smithery.ai | https://glama.ai | https://mcp.so", + description="复制链接到浏览器打开，获取免费 MCP 服务器", + label="🌐 获取 MCP 服务器", + disabled=True, + hint="魔搭 ModelScope 国内免费推荐，将 mcpServers 配置粘贴到「MCP Servers（Claude）」即可", + order=2, + ), + "example_config": ConfigField( + type=str, + default='{"mcpServers":{"time":{"url":"https://mcp.api-inference.modelscope.cn/server/mcp-server-time"}}}', + description="复制到 MCP Servers（Claude）可直接使用（免费时间服务器）", + label="📝 配置示例", + disabled=True, + order=3, + ), + }, + "plugin": { + "enabled": ConfigField( + type=bool, + default=False, + description="是否启用插件（默认关闭）", + label="启用插件", + ), + }, + "settings": { + "tool_prefix": ConfigField( + type=str, + default="mcp", + description="🏷️ 工具前缀 - 生成的工具名格式: {前缀}_{服务器名}_{工具名}", + label="🏷️ 工具前缀", + placeholder="mcp", + order=1, + ), + "connect_timeout": ConfigField( + type=float, + default=30.0, + description="⏱️ 连接超时（秒）", + label="⏱️ 连接超时（秒）", + min=5.0, + max=120.0, + step=5.0, + order=2, + ), + "call_timeout": ConfigField( + type=float, + default=60.0, + description="⏱️ 调用超时（秒）", + label="⏱️ 调用超时（秒）", + min=10.0, + max=300.0, + step=10.0, + order=3, + ), + "auto_connect": ConfigField( + type=bool, + default=True, + description="🔄 启动时自动连接所有已启用的服务器", + label="🔄 自动连接", + order=4, + ), + "retry_attempts": ConfigField( + type=int, + default=3, + description="🔁 连接失败时的重试次数", + label="🔁 重试次数", + min=0, + max=10, + order=5, + ), + "retry_interval": ConfigField( + type=float, + default=5.0, + description="⏳ 重试间隔（秒）", + label="⏳ 重试间隔（秒）", + min=1.0, + max=60.0, + step=1.0, + order=6, + ), + "heartbeat_enabled": ConfigField( + type=bool, + default=True, + description="💓 定期检测服务器连接状态", + label="💓 启用心跳检测", + order=7, + ), + "heartbeat_interval": ConfigField( + type=float, + default=60.0, + description="💓 基准心跳间隔（秒）", + label="💓 心跳间隔（秒）", + min=10.0, + max=300.0, + step=10.0, + hint="智能心跳会根据服务器稳定性自动调整", + order=8, + ), + "heartbeat_adaptive": ConfigField( + type=bool, + default=True, + description="🧠 根据服务器稳定性自动调整心跳间隔", + label="🧠 智能心跳", + hint="稳定服务器逐渐增加间隔，断开的服务器缩短间隔", + order=9, + ), + "heartbeat_max_multiplier": ConfigField( + type=float, + default=3.0, + description="稳定服务器的最大间隔倍数", + label="📈 最大间隔倍数", + min=1.5, + max=5.0, + step=0.5, + hint="稳定服务器心跳间隔最高可达 基准间隔 × 此值", + order=10, + ), + "auto_reconnect": ConfigField( + type=bool, + default=True, + description="🔄 检测到断开时自动尝试重连", + label="🔄 自动重连", + order=11, + ), + "max_reconnect_attempts": ConfigField( + type=int, + default=3, + description="🔄 连续重连失败后暂停重连", + label="🔄 最大重连次数", + min=1, + max=10, + order=12, + ), + # v1.7.0: 状态刷新配置 + "status_refresh_enabled": ConfigField( + type=bool, + default=True, + description="📊 定期更新 WebUI 状态显示", + label="📊 启用状态实时刷新", + hint="关闭后 WebUI 状态仅在启动时更新", + order=13, + ), + "status_refresh_interval": ConfigField( + type=float, + default=10.0, + description="📊 状态刷新间隔（秒）", + label="📊 状态刷新间隔（秒）", + min=5.0, + max=60.0, + step=5.0, + hint="值越小刷新越频繁，但会增加少量 CPU 消耗", + order=14, + ), + "enable_resources": ConfigField( + type=bool, + default=False, + description="📦 允许读取 MCP 服务器提供的资源", + label="📦 启用 Resources（实验性）", + order=11, + ), + "enable_prompts": ConfigField( + type=bool, + default=False, + description="📝 允许使用 MCP 服务器提供的提示模板", + label="📝 启用 Prompts（实验性）", + order=12, + ), + # v1.3.0 后处理配置 + "post_process_enabled": ConfigField( + type=bool, + default=False, + description="🔄 使用 LLM 对长结果进行摘要提炼", + label="🔄 启用结果后处理", + order=20, + ), + "post_process_threshold": ConfigField( + type=int, + default=500, + description="📏 结果长度超过此值才触发后处理", + label="📏 后处理阈值（字符）", + min=100, + max=5000, + step=100, + order=21, + ), + "post_process_max_tokens": ConfigField( + type=int, + default=500, + description="📝 LLM 摘要输出的最大 token 数", + label="📝 后处理最大输出 token", + min=100, + max=2000, + step=50, + order=22, + ), + "post_process_model": ConfigField( + type=str, + default="", + description="🤖 指定用于后处理的模型名称", + label="🤖 后处理模型（可选）", + placeholder="留空则使用 Utils 模型组", + order=23, + ), + "post_process_prompt": ConfigField( + type=str, + default="用户问题：{query}\\n\\n工具返回内容：\\n{result}\\n\\n请从上述内容中提取与用户问题最相关的关键信息，简洁准确地输出：", + description="📋 后处理提示词模板", + label="📋 后处理提示词模板", + input_type="textarea", + rows=8, + order=24, + ), + # v1.4.0 追踪配置 + "trace_enabled": ConfigField( + type=bool, + default=True, + description="🔍 记录工具调用详情", + label="🔍 启用调用追踪", + order=30, + ), + "trace_max_records": ConfigField( + type=int, + default=100, + description="内存中保留的最大记录数", + label="📊 追踪记录上限", + min=10, + max=1000, + order=31, + ), + "trace_log_enabled": ConfigField( + type=bool, + default=False, + description="是否将追踪记录写入日志文件", + label="📝 追踪日志文件", + hint="启用后记录写入 plugins/MaiBot_MCPBridgePlugin/logs/trace.jsonl", + order=32, + ), + # v1.4.0 缓存配置 + "cache_enabled": ConfigField( + type=bool, + default=False, + description="🗄️ 缓存相同参数的调用结果", + label="🗄️ 启用调用缓存", + hint="相同参数的调用会返回缓存结果，减少重复请求", + order=40, + ), + "cache_ttl": ConfigField( + type=int, + default=300, + description="缓存有效期（秒）", + label="⏱️ 缓存有效期（秒）", + min=60, + max=3600, + order=41, + ), + "cache_max_entries": ConfigField( + type=int, + default=200, + description="最大缓存条目数（超出后 LRU 淘汰）", + label="📦 最大缓存条目", + min=50, + max=1000, + order=42, + ), + "cache_exclude_tools": ConfigField( + type=str, + default="", + description="不缓存的工具（每行一个，支持通配符 *）", + label="🚫 缓存排除列表", + input_type="textarea", + rows=4, + hint="时间类、随机类工具建议排除，如 mcp_time_*", + order=43, + ), + }, + # v1.4.0 工具管理 + "tools": { + "tool_list": ConfigField( + type=str, + default="(启动后自动生成)", + description="当前已注册的 MCP 工具列表（只读）", + label="📋 工具清单", + input_type="textarea", + disabled=True, + rows=12, + hint="从此处复制工具名到下方禁用列表或工具链配置", + order=1, + ), + "disabled_tools": ConfigField( + type=str, + default="", + description="要禁用的工具名（每行一个）", + label="🚫 禁用工具列表", + input_type="textarea", + rows=6, + hint="从上方工具清单复制工具名，每行一个。禁用后该工具不会被 LLM 调用", + order=2, + ), + }, + # v1.8.0 工具链配置 + "tool_chains": { + "chains_enabled": ConfigField( + type=bool, + default=True, + description="🔗 启用工具链功能", + label="🔗 启用工具链", + hint="工具链可将多个工具按顺序执行，后续工具可使用前序工具的输出", + order=1, + ), + # 工具链使用指南 + "chains_guide": ConfigField( + type=str, + default="""工具链将多个 MCP 工具串联执行，后续步骤可使用前序步骤的输出 + +📌 变量语法: + ${input.参数名} - 用户输入的参数 + ${step.输出键} - 某步骤的输出（需设置 output_key） + ${prev} - 上一步的输出 + ${prev.字段} - 上一步输出(JSON)的某字段 + ${step.输出键.0.字段} / ${step.输出键[0].字段} - 访问数组下标 + ${step.输出键['return'][0]['location']} - 支持 bracket 写法 + +📌 测试命令: + /mcp chain list - 查看所有工具链 + /mcp chain 链名 {"参数":"值"} - 测试执行""", + description="工具链使用说明", + label="📖 使用指南", + input_type="textarea", + disabled=True, + rows=10, + order=2, + ), + # 快速添加工具链（表单式） + "quick_chain_name": ConfigField( + type=str, + default="", + description="工具链名称（英文，如 search_and_summarize）", + label="➕ 快速添加 - 名称", + placeholder="my_tool_chain", + hint="必填，将作为 LLM 可调用的工具名", + order=10, + ), + "quick_chain_desc": ConfigField( + type=str, + default="", + description="工具链描述（供 LLM 理解何时使用）", + label="➕ 快速添加 - 描述", + placeholder="先搜索内容，再获取详情并总结", + hint="必填，清晰描述工具链的用途", + order=11, + ), + "quick_chain_params": ConfigField( + type=str, + default="", + description="输入参数（每行一个，格式: 参数名=描述）", + label="➕ 快速添加 - 输入参数", + input_type="textarea", + rows=3, + placeholder="query=搜索关键词\nmax_results=最大结果数", + hint="定义用户需要提供的参数", + order=12, + ), + "quick_chain_steps": ConfigField( + type=str, + default="", + description="执行步骤（每行一个，格式: 工具名|参数JSON|输出键）", + label="➕ 快速添加 - 执行步骤", + input_type="textarea", + rows=5, + placeholder='mcp_server_search|{"keyword":"${input.query}"}|search_result\nmcp_server_detail|{"id":"${prev}"}|\n# 访问数组示例:\n# mcp_geo|{"q":"${input.query}"}|geo\n# mcp_next|{"location":"${step.geo.return.0.location}"}|', + hint="格式: 工具名|参数模板|输出键（输出键可选，用于后续步骤引用 ${step.xxx}）", + order=13, + ), + "quick_chain_add": ConfigField( + type=str, + default="", + description="填写上方信息后，在此输入 ADD 并保存即可添加", + label="➕ 确认添加", + placeholder="输入 ADD 并保存", + hint="添加后会自动合并到下方工具链列表", + order=14, + ), + # 工具链模板 + "chains_templates": ConfigField( + type=str, + default="""📋 常用工具链模板（复制到下方列表使用）: + +1️⃣ 搜索+详情模板: +{ + "name": "search_and_detail", + "description": "搜索内容并获取详情", + "input_params": {"query": "搜索关键词"}, + "steps": [ + {"tool_name": "搜索工具名", "args_template": {"keyword": "${input.query}"}, "output_key": "results"}, + {"tool_name": "详情工具名", "args_template": {"id": "${prev}"}} + ] +} + +2️⃣ 获取+处理模板: +{ + "name": "fetch_and_process", + "description": "获取数据并处理", + "input_params": {"url": "目标URL"}, + "steps": [ + {"tool_name": "获取工具名", "args_template": {"url": "${input.url}"}, "output_key": "data"}, + {"tool_name": "处理工具名", "args_template": {"content": "${step.data}"}} + ] +} + +3️⃣ 多步骤可选模板: +{ + "name": "multi_step_chain", + "description": "多步骤处理，部分可选", + "input_params": {"input": "输入内容"}, + "steps": [ + {"tool_name": "步骤1工具", "args_template": {"data": "${input.input}"}, "output_key": "step1"}, + {"tool_name": "步骤2工具", "args_template": {"data": "${prev}"}, "output_key": "step2", "optional": true}, + {"tool_name": "步骤3工具", "args_template": {"data": "${step.step1}"}} + ] +}""", + description="工具链配置模板参考", + label="📝 配置模板", + input_type="textarea", + disabled=True, + rows=15, + order=20, + ), + "chains_list": ConfigField( + type=str, + default="[]", + description="工具链配置（JSON 数组格式）", + label="📋 工具链列表", + input_type="textarea", + rows=20, + placeholder='''[ + { + "name": "search_and_detail", + "description": "先搜索再获取详情", + "input_params": {"query": "搜索关键词"}, + "steps": [ + {"tool_name": "mcp_server_search", "args_template": {"keyword": "${input.query}"}, "output_key": "search_result"}, + {"tool_name": "mcp_server_get_detail", "args_template": {"id": "${step.search_result}"}} + ] + } +]''', + hint="每个工具链包含 name、description、input_params、steps", + order=30, + ), + "chains_status": ConfigField( + type=str, + default="(启动后自动生成)", + description="当前已注册的工具链状态（只读）", + label="📊 工具链状态", + input_type="textarea", + disabled=True, + rows=8, + order=40, + ), + }, + # v1.9.0 ReAct 软流程配置 + "react": { + "react_enabled": ConfigField( + type=bool, + default=False, + description="🔄 将 MCP 工具注册到记忆检索 ReAct 系统", + label="🔄 启用 ReAct 集成", + hint="启用后，MaiBot 的 ReAct Agent 可在记忆检索时调用 MCP 工具", + order=1, + ), + "react_guide": ConfigField( + type=str, + default="""ReAct 软流程说明: + +📌 什么是 ReAct? +ReAct (Reasoning + Acting) 是 LLM 自主决策的多轮工具调用模式。 +与 Workflow 硬流程不同，ReAct 由 LLM 动态决定调用哪些工具。 + +📌 工作原理: +1. 用户提问 → LLM 分析需要什么信息 +2. LLM 选择调用工具 → 获取结果 +3. LLM 观察结果 → 决定是否需要更多信息 +4. 重复 2-3 直到信息足够 → 生成最终回答 + +📌 与 Workflow 的区别: +- ReAct (软流程): LLM 自主决策，灵活但不可预测 +- Workflow (硬流程): 用户预定义，固定流程，可靠可控 + +📌 使用场景: +- 复杂问题需要多步推理 +- 不确定需要调用哪些工具 +- 需要根据中间结果动态调整""", + description="ReAct 软流程使用说明", + label="📖 使用指南", + input_type="textarea", + disabled=True, + rows=15, + order=2, + ), + "filter_mode": ConfigField( + type=str, + default="whitelist", + description="过滤模式", + label="📋 过滤模式", + choices=["whitelist", "blacklist"], + hint="whitelist: 只注册列出的工具；blacklist: 排除列出的工具", + order=3, + ), + "tool_filter": ConfigField( + type=str, + default="", + description="工具过滤列表（每行一个，支持通配符 * 和精确匹配）", + label="🔍 工具过滤列表", + input_type="textarea", + rows=6, + placeholder="""# 精确匹配示例: +mcp_bing_web_search_bing_search +mcp_mcmod_search_mod + +# 通配符示例: +mcp_*_search_* +mcp_bing_*""", + hint="白名单模式: 只注册列出的工具；黑名单模式: 排除列出的工具。支持 # 注释", + order=4, + ), + "react_status": ConfigField( + type=str, + default="(启动后自动生成)", + description="当前已注册到 ReAct 的工具状态（只读）", + label="📊 ReAct 工具状态", + input_type="textarea", + disabled=True, + rows=6, + order=10, + ), + }, + # v1.4.0 权限控制 + "permissions": { + "perm_enabled": ConfigField( + type=bool, + default=False, + description="🔐 按群/用户限制工具使用", + label="🔐 启用权限控制", + order=1, + ), + "perm_default_mode": ConfigField( + type=str, + default="allow_all", + description="默认模式：allow_all（默认允许）或 deny_all（默认禁止）", + label="📋 默认模式", + placeholder="allow_all", + hint="allow_all: 未配置的默认允许；deny_all: 未配置的默认禁止", + order=2, + ), + # 快捷配置（简化版） + "quick_deny_groups": ConfigField( + type=str, + default="", + description="禁止使用所有 MCP 工具的群号（每行一个）", + label="🚫 禁用群列表（快捷）", + input_type="textarea", + rows=4, + hint="填入群号，该群将无法使用任何 MCP 工具", + order=3, + ), + "quick_allow_users": ConfigField( + type=str, + default="", + description="始终允许使用所有工具的用户 QQ 号（管理员白名单，每行一个）", + label="✅ 管理员白名单（快捷）", + input_type="textarea", + rows=3, + hint="填入 QQ 号，该用户在任何场景都可使用 MCP 工具", + order=4, + ), + # 高级配置 + "perm_rules": ConfigField( + type=str, + default="[]", + description="高级权限规则（JSON 格式，可针对特定工具配置）", + label="📜 高级权限规则（可选）", + input_type="textarea", + rows=10, + placeholder='''[ + {"tool": "mcp_*_delete_*", "denied": ["qq:123456:group"]} +]''', + hint="格式: qq:ID:group/private/user，工具名支持通配符 *", + order=10, + ), + }, + # v2.0: 服务器配置统一为 Claude Desktop mcpServers 规范（JSON） + "servers": { + "claude_config_json": ConfigField( + type=str, + default='{"mcpServers":{}}', + description="Claude Desktop 规范的 MCP 配置（JSON）", + label="🔌 MCP Servers（Claude 规范）", + input_type="textarea", + rows=18, + hint="仅支持 Claude Desktop 的 mcpServers JSON。每个服务器需包含 command(stdio) 或 url(remote)。", + order=1, + ), + "claude_config_guide": ConfigField( + type=str, + default="""示例： +{ + "mcpServers": { + "fetch": { "command": "uvx", "args": ["mcp-server-fetch"] }, + "time": { "url": "https://mcp.api-inference.modelscope.cn/server/mcp-server-time" } + } +} + +可选字段： +- enabled: true/false +- headers: {"Authorization":"Bearer ..."} +- env: {"KEY":"VALUE"} +- transport/type: "streamable_http" | "http" | "sse"（remote 可选，默认 streamable_http） +""", + description="配置说明（只读）", + label="📖 配置说明", + input_type="textarea", + disabled=True, + rows=12, + order=2, + ), + }, + "status": { + "connection_status": ConfigField( + type=str, + default="未初始化", + description="当前 MCP 服务器连接状态和工具列表", + label="📊 连接状态", + input_type="textarea", + disabled=True, + rows=15, + hint="此状态仅在插件启动时更新。查询实时状态请发送 /mcp 命令", + order=1, + ), + }, + } + + @staticmethod + def _fix_config_multiline_strings(config_path: Path) -> bool: + """修复配置文件中的多行字符串格式问题 + + 处理两种情况： + 1. 带转义 \\n 的单行字符串（json.dumps 生成） + 2. 跨越多行但使用普通双引号的字符串（控制字符错误） + + Returns: + bool: 是否进行了修复 + """ + if not config_path.exists(): + return False + + try: + content = config_path.read_text(encoding="utf-8") + + # 情况1: 修复带转义 \n 的单行字符串 + # 匹配: key = "内容包含\n的字符串" + pattern1 = r'^(\s*\w+\s*=\s*)"((?:[^"\\]|\\.)*\\n(?:[^"\\]|\\.)*)"(\s*)$' + + # 情况2: 修复跨越多行的普通双引号字符串 + # 匹配: key = "第一行 + # 第二行 + # 第三行" + pattern2_start = r'^(\s*\w+\s*=\s*)"([^"]*?)$' # 开始行 + pattern2_end = r'^([^"]*)"(\s*)$' # 结束行 + + lines = content.split("\n") + fixed_lines = [] + modified = False + + i = 0 + while i < len(lines): + line = lines[i] + + # 情况1: 单行带转义换行符 + match1 = re.match(pattern1, line) + if match1: + prefix = match1.group(1) + value = match1.group(2) + suffix = match1.group(3) + # 将转义的换行符还原为实际换行符 + unescaped = value.replace("\\n", "\n").replace("\\t", "\t").replace('\\"', '"').replace("\\\\", "\\") + fixed_line = f'{prefix}"""{unescaped}"""{suffix}' + fixed_lines.append(fixed_line) + modified = True + i += 1 + continue + + # 情况2: 跨越多行的字符串 + match2_start = re.match(pattern2_start, line) + if match2_start: + prefix = match2_start.group(1) + first_part = match2_start.group(2) + + # 收集后续行直到找到结束引号 + multiline_parts = [first_part] + j = i + 1 + found_end = False + + while j < len(lines): + next_line = lines[j] + match2_end = re.match(pattern2_end, next_line) + if match2_end: + multiline_parts.append(match2_end.group(1)) + suffix = match2_end.group(2) + found_end = True + j += 1 + break + else: + multiline_parts.append(next_line) + j += 1 + + if found_end and len(multiline_parts) > 1: + # 合并为三引号字符串 + full_value = "\n".join(multiline_parts) + fixed_line = f'{prefix}"""{full_value}"""{suffix}' + fixed_lines.append(fixed_line) + modified = True + i = j + continue + + fixed_lines.append(line) + i += 1 + + if modified: + config_path.write_text("\n".join(fixed_lines), encoding="utf-8") + logger.info("已自动修复配置文件中的多行字符串格式") + return True + + return False + except Exception as e: + logger.warning(f"修复配置文件格式失败: {e}") + return False + + def __init__(self, *args, **kwargs): + global _plugin_instance + + # 在父类初始化前尝试修复配置文件格式 + config_path = Path(__file__).parent / "config.toml" + self._fix_config_multiline_strings(config_path) + + super().__init__(*args, **kwargs) + self._initialized = False + self._status_refresh_running = False + self._status_refresh_task: Optional[asyncio.Task] = None + self._last_persisted_display_hash: str = "" + self._last_servers_config_error: str = "" + _plugin_instance = self + + # 配置 MCP 管理器 + settings = self.config.get("settings", {}) + mcp_manager.configure(settings) + + # v1.4.0: 配置追踪器 + trace_log_path = Path(__file__).parent / "logs" / "trace.jsonl" + tool_call_tracer.configure( + enabled=settings.get("trace_enabled", True), + max_records=settings.get("trace_max_records", 100), + log_enabled=settings.get("trace_log_enabled", False), + log_path=trace_log_path, + ) + + # v1.4.0: 配置缓存 + tool_call_cache.configure( + enabled=settings.get("cache_enabled", False), + ttl=settings.get("cache_ttl", 300), + max_entries=settings.get("cache_max_entries", 200), + exclude_tools=settings.get("cache_exclude_tools", ""), + ) + + # v1.4.0: 配置权限检查器 + perm_config = self.config.get("permissions", {}) + permission_checker.configure( + enabled=perm_config.get("perm_enabled", False), + default_mode=perm_config.get("perm_default_mode", "allow_all"), + rules_json=perm_config.get("perm_rules", "[]"), + quick_deny_groups=perm_config.get("quick_deny_groups", ""), + quick_allow_users=perm_config.get("quick_allow_users", ""), + ) + + # 注册状态变化回调 + mcp_manager.set_status_change_callback(self._update_status_display) + + # v2.0: 服务器配置统一由 servers.claude_config_json 提供（不再通过 WebUI 导入/快速添加写入旧 servers.list） + + # v1.8.0: 初始化工具链管理器 + tool_chain_manager.set_executor(mcp_manager) + self._load_tool_chains() + + def _persist_runtime_displays(self) -> None: + """将 WebUI 只读展示字段写回配置文件，使 WebUI 能正确显示运行状态。""" + try: + config_path = Path(self.plugin_dir) / self.config_file_name + + payload = { + "status.connection_status": str(self.config.get("status", {}).get("connection_status", "") or ""), + "tools.tool_list": str(self.config.get("tools", {}).get("tool_list", "") or ""), + "tool_chains.chains_status": str(self.config.get("tool_chains", {}).get("chains_status", "") or ""), + "react.react_status": str(self.config.get("react", {}).get("react_status", "") or ""), + } + digest = hashlib.sha256(json.dumps(payload, ensure_ascii=False).encode("utf-8")).hexdigest() + if digest == self._last_persisted_display_hash: + return + + self._save_config_to_file(self.config, str(config_path)) + self._last_persisted_display_hash = digest + except Exception as e: + logger.debug(f"写回运行状态到配置文件失败: {e}") + + def _process_quick_add_chain(self) -> None: + """v1.8.0: 处理快速添加工具链表单""" + chains_config = self.config.get("tool_chains", {}) + + # 检查是否触发添加 + add_trigger = chains_config.get("quick_chain_add", "").strip().upper() + if add_trigger != "ADD": + return + + # 获取表单数据 + chain_name = chains_config.get("quick_chain_name", "").strip() + chain_desc = chains_config.get("quick_chain_desc", "").strip() + params_str = chains_config.get("quick_chain_params", "").strip() + steps_str = chains_config.get("quick_chain_steps", "").strip() + + # 验证必填字段 + if not chain_name: + logger.warning("快速添加工具链: 名称不能为空") + self._clear_quick_chain_fields() + return + + if not chain_desc: + logger.warning("快速添加工具链: 描述不能为空") + self._clear_quick_chain_fields() + return + + if not steps_str: + logger.warning("快速添加工具链: 步骤不能为空") + self._clear_quick_chain_fields() + return + + # 解析输入参数 + input_params = {} + if params_str: + for line in params_str.split("\n"): + line = line.strip() + if not line or "=" not in line: + continue + parts = line.split("=", 1) + param_name = parts[0].strip() + param_desc = parts[1].strip() if len(parts) > 1 else param_name + input_params[param_name] = param_desc + + # 解析步骤 + steps = [] + for line in steps_str.split("\n"): + line = line.strip() + if not line: + continue + + parts = line.split("|") + if len(parts) < 2: + logger.warning(f"快速添加工具链: 步骤格式错误: {line}") + continue + + tool_name = parts[0].strip() + args_str = parts[1].strip() if len(parts) > 1 else "{}" + output_key = parts[2].strip() if len(parts) > 2 else "" + + # 解析参数 JSON + try: + args_template = json.loads(args_str) if args_str else {} + except json.JSONDecodeError: + logger.warning(f"快速添加工具链: 参数 JSON 格式错误: {args_str}") + args_template = {} + + steps.append({ + "tool_name": tool_name, + "args_template": args_template, + "output_key": output_key, + }) + + if not steps: + logger.warning("快速添加工具链: 没有有效的步骤") + self._clear_quick_chain_fields() + return + + # 构建新工具链 + new_chain = { + "name": chain_name, + "description": chain_desc, + "input_params": input_params, + "steps": steps, + "enabled": True, + } + + # 获取现有工具链列表 + chains_json = chains_config.get("chains_list", "[]") + try: + chains_list = json.loads(chains_json) if chains_json.strip() else [] + except json.JSONDecodeError: + chains_list = [] + + # 检查是否已存在同名工具链 + for existing in chains_list: + if existing.get("name") == chain_name: + logger.info(f"快速添加: 工具链 {chain_name} 已存在，将更新") + chains_list.remove(existing) + break + + # 添加新工具链 + chains_list.append(new_chain) + new_chains_json = json.dumps(chains_list, ensure_ascii=False, indent=2) + + # 更新配置 + self.config["tool_chains"]["chains_list"] = new_chains_json + + # 清空表单字段 + self._clear_quick_chain_fields() + + # 保存到配置文件 + self._save_chains_list(new_chains_json) + + logger.info(f"快速添加: 已添加工具链 {chain_name} ({len(steps)} 个步骤)") + + def _clear_quick_chain_fields(self) -> None: + """清空快速添加工具链表单字段""" + if "tool_chains" not in self.config: + self.config["tool_chains"] = {} + self.config["tool_chains"]["quick_chain_name"] = "" + self.config["tool_chains"]["quick_chain_desc"] = "" + self.config["tool_chains"]["quick_chain_params"] = "" + self.config["tool_chains"]["quick_chain_steps"] = "" + self.config["tool_chains"]["quick_chain_add"] = "" + + def _save_chains_list(self, chains_json: str) -> None: + """保存工具链列表到配置文件""" + try: + config_path = Path(self.plugin_dir) / self.config_file_name + self._save_config_to_file(self.config, str(config_path)) + logger.info("工具链列表已保存到配置文件") + except Exception as e: + logger.warning(f"保存工具链列表失败: {e}") + + def _load_tool_chains(self) -> None: + """v1.8.0: 加载工具链配置""" + # 先处理快速添加 + self._process_quick_add_chain() + + chains_config = self.config.get("tool_chains", {}) + if not isinstance(chains_config, dict): + chains_config = {} + + # 兼容旧版本：部分版本可能使用 tool_chain 或其他字段名 + if not chains_config: + legacy_section = self.config.get("tool_chain") + if isinstance(legacy_section, dict): + chains_config = legacy_section + self.config["tool_chains"] = legacy_section + + # 兼容旧版本：chains_list 字段名变化 + chains_json = str(chains_config.get("chains_list", "") or "") + if not chains_json.strip(): + for legacy_key in ("list", "chains", "workflow_list", "workflows", "toolchains"): + legacy_val = chains_config.get(legacy_key) + if legacy_val is None: + continue + + if isinstance(legacy_val, str) and legacy_val.strip(): + chains_json = legacy_val + break + + if isinstance(legacy_val, list): + chains_json = json.dumps(legacy_val, ensure_ascii=False, indent=2) + break + + if isinstance(legacy_val, dict): + chains_json = json.dumps([legacy_val], ensure_ascii=False, indent=2) + break + + if chains_json.strip(): + if "tool_chains" not in self.config or not isinstance(self.config.get("tool_chains"), dict): + self.config["tool_chains"] = {} + self.config["tool_chains"]["chains_list"] = chains_json + logger.info("检测到旧版 Workflow 配置字段，已自动迁移为 tool_chains.chains_list（请在 WebUI 保存一次以固化）") + + chains_config = self.config.get("tool_chains", {}) + if not isinstance(chains_config, dict): + chains_config = {} + + if not chains_config.get("chains_enabled", True): + logger.info("工具链功能已禁用") + return + + chains_json = str(chains_config.get("chains_list", "[]") or "") + if not chains_json or not chains_json.strip(): + return + + # 清空现有工具链 + tool_chain_manager.clear() + tool_chain_registry.clear() + + # 加载新配置 + loaded, errors = tool_chain_manager.load_from_json(chains_json) + + if errors: + for err in errors: + logger.warning(f"工具链配置错误: {err}") + + if loaded > 0: + logger.info(f"已加载 {loaded} 个工具链") + # 注册工具链到组件系统 + self._register_tool_chains() + self._update_chains_status_display() + + def _register_tool_chains(self) -> None: + """v1.8.1: 将工具链注册到 MaiBot 组件系统，使 LLM 可调用""" + from src.plugin_system.core.component_registry import component_registry + + chain_count = 0 + for chain_name, chain in tool_chain_manager.get_enabled_chains().items(): + try: + expected_tool_name = f"chain_{chain.name}".replace("-", "_").replace(".", "_") + if component_registry.get_component_info(expected_tool_name, ComponentType.TOOL): + chain_count += 1 + logger.debug(f"🔗 工具链已存在，跳过重复注册: {expected_tool_name}") + continue + + info, tool_class = tool_chain_registry.register_chain(chain) + info.plugin_name = self.plugin_name + + if component_registry.register_component(info, tool_class): + chain_count += 1 + logger.info(f"🔗 注册工具链: {tool_class.name}") + else: + logger.warning(f"⚠️ 工具链注册被跳过（可能已存在）: {tool_class.name}") + except Exception as e: + logger.error(f"注册工具链 {chain_name} 失败: {e}") + + if chain_count > 0: + logger.info(f"已注册 {chain_count} 个工具链到组件系统") + + def _register_tools_to_react(self) -> int: + """v1.9.0: 将 MCP 工具注册到记忆检索 ReAct 系统（软流程） + + 这样 MaiBot 的 ReAct Agent 在检索记忆时可以调用 MCP 工具， + 实现 LLM 自主决策的多轮工具调用。 + + Returns: + int: 成功注册的工具数量 + """ + try: + from src.memory_system.retrieval_tools import register_memory_retrieval_tool + except ImportError: + logger.warning("无法导入记忆检索工具注册模块，跳过 ReAct 工具注册") + return 0 + + react_config = self.config.get("react", {}) + filter_mode = react_config.get("filter_mode", "whitelist") + tool_filter = react_config.get("tool_filter", "").strip() + + # 解析过滤列表（支持 # 注释） + filter_patterns = [] + for line in tool_filter.split("\n"): + line = line.strip() + if line and not line.startswith("#"): + filter_patterns.append(line) + + registered_count = 0 + disabled_tools = self._get_disabled_tools() + registered_tools = [] # 记录已注册的工具名 + + for tool_key, (tool_info, _) in mcp_manager.all_tools.items(): + tool_name = tool_key.replace("-", "_").replace(".", "_") + + # 跳过禁用的工具 + if tool_name in disabled_tools: + continue + + # 应用过滤器 + if filter_patterns: + matched = any( + fnmatch.fnmatch(tool_name, p) or tool_name == p + for p in filter_patterns + ) + + if filter_mode == "whitelist": + # 白名单模式：只注册匹配的 + if not matched: + continue + else: + # 黑名单模式：排除匹配的 + if matched: + continue + + try: + # 转换参数格式 + parameters = self._convert_mcp_params_to_react_format(tool_info.input_schema) + + # 创建异步执行函数（使用闭包捕获 tool_key） + def make_execute_func(tk: str): + async def execute_func(**kwargs) -> str: + result = await mcp_manager.call_tool(tk, kwargs) + if result.success: + return result.content or "(无返回内容)" + else: + return f"工具调用失败: {result.error}" + return execute_func + + execute_func = make_execute_func(tool_key) + + # 注册到 ReAct 系统 + register_memory_retrieval_tool( + name=f"mcp_{tool_name}", + description=f"{tool_info.description} [MCP: {tool_info.server_name}]", + parameters=parameters, + execute_func=execute_func, + ) + + registered_count += 1 + registered_tools.append(f"mcp_{tool_name}") + logger.debug(f"🔄 注册 ReAct 工具: mcp_{tool_name}") + + except Exception as e: + logger.warning(f"注册 ReAct 工具 {tool_name} 失败: {e}") + + if registered_count > 0: + mode_str = "白名单" if filter_mode == "whitelist" else "黑名单" + logger.info(f"已注册 {registered_count} 个 MCP 工具到 ReAct 系统 (过滤模式: {mode_str})") + + # 更新状态显示 + self._update_react_status_display(registered_tools, filter_mode, filter_patterns) + + return registered_count + + def _update_react_status_display(self, registered_tools: List[str], filter_mode: str, filter_patterns: List[str]) -> None: + """更新 ReAct 工具状态显示""" + if not registered_tools: + status_text = "(未注册任何工具)" + else: + mode_str = "白名单" if filter_mode == "whitelist" else "黑名单" + lines = [f"📊 已注册 {len(registered_tools)} 个工具 (模式: {mode_str})"] + if filter_patterns: + lines.append(f"过滤规则: {len(filter_patterns)} 条") + lines.append("") + for tool in registered_tools[:20]: + lines.append(f" • {tool}") + if len(registered_tools) > 20: + lines.append(f" ... 还有 {len(registered_tools) - 20} 个") + status_text = "\n".join(lines) + + # 更新内存配置 + if "react" not in self.config: + self.config["react"] = {} + self.config["react"]["react_status"] = status_text + + def _convert_mcp_params_to_react_format(self, input_schema: Dict) -> List[Dict[str, Any]]: + """将 MCP 工具参数转换为 ReAct 工具参数格式""" + parameters = [] + + if not input_schema: + return parameters + + properties = input_schema.get("properties", {}) + required = input_schema.get("required", []) + + for param_name, param_info in properties.items(): + param_type = param_info.get("type", "string") + description = param_info.get("description", f"参数 {param_name}") + is_required = param_name in required + + parameters.append({ + "name": param_name, + "type": param_type, + "description": description, + "required": is_required, + }) + + return parameters + + def _update_chains_status_display(self) -> None: + """v1.8.0: 更新工具链状态显示""" + chains = tool_chain_manager.get_all_chains() + + if not chains: + status_text = "(无工具链配置)" + else: + lines = [f"📊 已配置 {len(chains)} 个工具链:\n"] + for name, chain in chains.items(): + status = "✅" if chain.enabled else "❌" + # 显示工具链基本信息 + lines.append(f"{status} chain_{name}") + lines.append(f" 描述: {chain.description[:40]}{'...' if len(chain.description) > 40 else ''}") + + # 显示输入参数 + if chain.input_params: + params = ", ".join(chain.input_params.keys()) + lines.append(f" 参数: {params}") + + # 显示步骤 + lines.append(f" 步骤: {len(chain.steps)} 个") + for i, step in enumerate(chain.steps): + opt = " (可选)" if step.optional else "" + out = f" → {step.output_key}" if step.output_key else "" + lines.append(f" {i+1}. {step.tool_name}{out}{opt}") + lines.append("") + + status_text = "\n".join(lines) + + # 更新内存配置 + if "tool_chains" not in self.config: + self.config["tool_chains"] = {} + self.config["tool_chains"]["chains_status"] = status_text + + def _get_disabled_tools(self) -> set: + """v1.4.0: 获取禁用的工具列表""" + tools_config = self.config.get("tools", {}) + disabled_str = tools_config.get("disabled_tools", "") + return {t.strip() for t in disabled_str.strip().split("\n") if t.strip()} + + async def _async_connect_servers(self) -> None: + """异步连接所有配置的 MCP 服务器（v1.5.0: 并行连接优化）""" + import asyncio + settings = self.config.get("settings", {}) + + servers_config = self._load_mcp_servers_config() + + if not servers_config: + logger.warning("未配置任何 MCP 服务器") + self._initialized = True + self._update_status_display() + self._update_tool_list_display() + self._update_chains_status_display() + self._start_status_refresher() + self._persist_runtime_displays() + return + + auto_connect = settings.get("auto_connect", True) + if not auto_connect: + logger.info("auto_connect 已禁用，跳过自动连接") + self._initialized = True + self._update_status_display() + self._update_tool_list_display() + self._update_chains_status_display() + self._start_status_refresher() + self._persist_runtime_displays() + return + + tool_prefix = settings.get("tool_prefix", "mcp") + disabled_tools = self._get_disabled_tools() + enable_resources = settings.get("enable_resources", False) + enable_prompts = settings.get("enable_prompts", False) + + # 解析所有服务器配置 + enabled_configs: List[MCPServerConfig] = [] + for idx, server_conf in enumerate(servers_config): + server_name = server_conf.get("name", f"unknown_{idx}") + + if not server_conf.get("enabled", True): + logger.info(f"服务器 {server_name} 已禁用，跳过") + continue + + try: + config = self._parse_server_config(server_conf) + enabled_configs.append(config) + except Exception as e: + logger.error(f"解析服务器 {server_name} 配置失败: {e}") + + if not enabled_configs: + logger.warning("没有已启用的 MCP 服务器") + self._initialized = True + self._update_status_display() + self._update_tool_list_display() + self._update_chains_status_display() + self._start_status_refresher() + self._persist_runtime_displays() + return + + logger.info(f"准备并行连接 {len(enabled_configs)} 个 MCP 服务器") + + # v1.5.0: 并行连接所有服务器 + async def connect_single_server(config: MCPServerConfig) -> Tuple[MCPServerConfig, bool]: + """连接单个服务器""" + logger.info(f"正在连接服务器: {config.name} ({config.transport.value})") + try: + success = await mcp_manager.add_server(config) + if success: + logger.info(f"✅ 服务器 {config.name} 连接成功") + # 获取资源和提示模板 + if enable_resources: + try: + await mcp_manager.fetch_resources_for_server(config.name) + except Exception as e: + logger.warning(f"服务器 {config.name} 获取资源列表失败: {e}") + if enable_prompts: + try: + await mcp_manager.fetch_prompts_for_server(config.name) + except Exception as e: + logger.warning(f"服务器 {config.name} 获取提示模板列表失败: {e}") + else: + logger.warning(f"❌ 服务器 {config.name} 连接失败") + return config, success + except Exception as e: + logger.error(f"❌ 服务器 {config.name} 连接异常: {e}") + return config, False + + # 并行执行所有连接 + start_time = time.time() + results = await asyncio.gather( + *[connect_single_server(cfg) for cfg in enabled_configs], + return_exceptions=True + ) + connect_duration = time.time() - start_time + + # 统计连接结果 + success_count = 0 + failed_count = 0 + for result in results: + if isinstance(result, Exception): + failed_count += 1 + logger.error(f"连接任务异常: {result}") + elif isinstance(result, tuple): + _, success = result + if success: + success_count += 1 + else: + failed_count += 1 + + logger.info(f"并行连接完成: {success_count} 成功, {failed_count} 失败, 耗时 {connect_duration:.2f}s") + + # 注册所有工具 + from src.plugin_system.core.component_registry import component_registry + registered_count = 0 + + for tool_key, (tool_info, _) in mcp_manager.all_tools.items(): + tool_name = tool_key.replace("-", "_").replace(".", "_") + is_disabled = tool_name in disabled_tools + + info, tool_class = mcp_tool_registry.register_tool( + tool_key, tool_info, tool_prefix, disabled=is_disabled + ) + info.plugin_name = self.plugin_name + + if component_registry.register_component(info, tool_class): + registered_count += 1 + status = "🚫" if is_disabled else "✅" + logger.info(f"{status} 注册 MCP 工具: {tool_class.name}") + else: + logger.warning(f"❌ 注册 MCP 工具失败: {tool_class.name}") + + chains_config = self.config.get("tool_chains", {}) + chains_enabled = bool(chains_config.get("chains_enabled", True)) if isinstance(chains_config, dict) else True + chain_count = len(tool_chain_manager.get_enabled_chains()) if chains_enabled else 0 + + # v1.9.0: 注册 MCP 工具到记忆检索 ReAct 系统（软流程） + react_count = 0 + react_config = self.config.get("react", {}) + if react_config.get("react_enabled", False): + react_count = self._register_tools_to_react() + + self._initialized = True + logger.info(f"MCP 桥接插件初始化完成，已注册 {registered_count} 个工具，{chain_count} 个工具链，{react_count} 个 ReAct 工具") + + # 更新状态显示 + self._update_status_display() + self._update_tool_list_display() + self._update_chains_status_display() + self._start_status_refresher() + self._persist_runtime_displays() + + def _start_status_refresher(self) -> None: + """启动 WebUI 状态刷新任务（不写入磁盘）""" + task = getattr(self, "_status_refresh_task", None) + if task and not task.done(): + return + + self._status_refresh_running = True + self._status_refresh_task = asyncio.create_task(self._status_refresh_loop()) + + async def _stop_status_refresher(self) -> None: + """停止 WebUI 状态刷新任务""" + self._status_refresh_running = False + task = getattr(self, "_status_refresh_task", None) + if task: + task.cancel() + try: + await task + except asyncio.CancelledError: + pass + self._status_refresh_task = None + + async def _status_refresh_loop(self) -> None: + """定期刷新 WebUI 展示字段（状态/工具列表/工具链状态）""" + while getattr(self, "_status_refresh_running", False): + try: + settings = self.config.get("settings", {}) + enabled = bool(settings.get("status_refresh_enabled", True)) + interval = float(settings.get("status_refresh_interval", 10.0) or 10.0) + interval = max(5.0, min(interval, 60.0)) + + if enabled and self._initialized: + self._update_status_display() + self._update_tool_list_display() + self._update_chains_status_display() + self._persist_runtime_displays() + + await asyncio.sleep(interval if enabled else 5.0) + except asyncio.CancelledError: + break + except Exception as e: + logger.debug(f"状态刷新任务异常: {e}") + await asyncio.sleep(5.0) + + def _load_mcp_servers_config(self) -> List[Dict[str, Any]]: + """v2.0: 从 Claude mcpServers JSON 加载服务器配置。 + + - 唯一主入口：config.servers.claude_config_json + - 兼容：若旧版 servers.list 存在且 claude_config_json 为空，会自动迁移并写回内存配置 + """ + servers_section = self.config.get("servers", {}) + if not isinstance(servers_section, dict): + servers_section = {} + + claude_json = str(servers_section.get("claude_config_json", "") or "") + + if not claude_json.strip(): + legacy_list = str(servers_section.get("list", "") or "") + migrated = legacy_servers_list_to_claude_config(legacy_list) + if migrated: + claude_json = migrated + if "servers" not in self.config: + self.config["servers"] = {} + self.config["servers"]["claude_config_json"] = migrated + logger.info("检测到旧版 servers.list，已自动迁移为 Claude mcpServers（请在 WebUI 保存一次以固化）") + + if not claude_json.strip(): + self._last_servers_config_error = "未配置任何 MCP 服务器（请在 WebUI 的「MCP Servers（Claude）」粘贴 mcpServers JSON）" + return [] + + try: + servers = parse_claude_mcp_config(claude_json) + except ClaudeConfigError as e: + self._last_servers_config_error = str(e) + logger.error(f"Claude mcpServers 配置解析失败: {e}") + return [] + except Exception as e: + self._last_servers_config_error = str(e) + logger.error(f"Claude mcpServers 配置解析异常: {e}") + return [] + + self._last_servers_config_error = "" + + # 保留未知字段（如 post_process）供旧功能使用 + raw_mapping: Dict[str, Any] = {} + try: + parsed = json.loads(claude_json) + mapping = parsed.get("mcpServers", parsed) + if isinstance(mapping, dict): + raw_mapping = mapping + except Exception: + raw_mapping = {} + + configs: List[Dict[str, Any]] = [] + for srv in servers: + raw = raw_mapping.get(srv.name, {}) + cfg: Dict[str, Any] = raw.copy() if isinstance(raw, dict) else {} + cfg.update( + { + "name": srv.name, + "enabled": srv.enabled, + "transport": srv.transport, + "command": srv.command, + "args": srv.args, + "env": srv.env, + "url": srv.url, + "headers": srv.headers, + } + ) + configs.append(cfg) + + return configs + + def _parse_server_config(self, conf: Dict) -> MCPServerConfig: + """解析服务器配置字典""" + transport_str = conf.get("transport", "stdio").lower() + + transport_map = { + "stdio": TransportType.STDIO, + "sse": TransportType.SSE, + "http": TransportType.HTTP, + "streamable_http": TransportType.STREAMABLE_HTTP, + } + transport = transport_map.get(transport_str, TransportType.STDIO) + + return MCPServerConfig( + name=conf.get("name", "unnamed"), + enabled=conf.get("enabled", True), + transport=transport, + command=conf.get("command", ""), + args=conf.get("args", []), + env=conf.get("env", {}), + url=conf.get("url", ""), + headers=conf.get("headers", {}), # v1.4.2: 鉴权头支持 + ) + + def _update_tool_list_display(self) -> None: + """v1.4.0: 更新工具列表显示""" + tools = mcp_manager.all_tools + disabled_tools = self._get_disabled_tools() + + lines = [] + by_server: Dict[str, List[str]] = {} + + for tool_key, (tool_info, _) in tools.items(): + tool_name = tool_key.replace("-", "_").replace(".", "_") + if tool_info.server_name not in by_server: + by_server[tool_info.server_name] = [] + + is_disabled = tool_name in disabled_tools + status = " ❌" if is_disabled else "" + by_server[tool_info.server_name].append(f" • {tool_name}{status}") + + for srv_name, tool_list in by_server.items(): + lines.append(f"📦 {srv_name} ({len(tool_list)}个工具):") + lines.extend(tool_list) + lines.append("") + + if not by_server: + lines.append("(无已注册工具)") + + tool_list_text = "\n".join(lines) + + # 更新内存配置 + if "tools" not in self.config: + self.config["tools"] = {} + self.config["tools"]["tool_list"] = tool_list_text + + def _update_status_display(self) -> None: + """更新配置文件中的状态显示字段""" + status = mcp_manager.get_status() + settings = self.config.get("settings", {}) + lines = [] + + cfg_err = str(getattr(self, "_last_servers_config_error", "") or "").strip() + if cfg_err: + lines.append(f"⚠️ 配置: {cfg_err}") + lines.append("") + + lines.append(f"服务器: {status['connected_servers']}/{status['total_servers']} 已连接") + lines.append(f"工具数: {status['total_tools']}") + if settings.get("enable_resources", False): + lines.append(f"资源数: {status.get('total_resources', 0)}") + if settings.get("enable_prompts", False): + lines.append(f"模板数: {status.get('total_prompts', 0)}") + lines.append(f"心跳: {'运行中' if status['heartbeat_running'] else '已停止'}") + lines.append("") + + tools = mcp_manager.all_tools + + for name, info in status.get("servers", {}).items(): + icon = "✅" if info["connected"] else "❌" + lines.append(f"{icon} {name} ({info['transport']})") + + # v1.7.0: 显示断路器状态 + cb_status = info.get("circuit_breaker", {}) + cb_state = cb_status.get("state", "closed") + if cb_state == "open": + lines.append(" ⚡ 断路器: 熔断中") + elif cb_state == "half_open": + lines.append(" ⚡ 断路器: 试探中") + + server_tools = [t.name for key, (t, _) in tools.items() if t.server_name == name] + if server_tools: + for tool_name in server_tools: + lines.append(f" • {tool_name}") + else: + lines.append(" (无工具)") + + if not status.get("servers"): + lines.append("(无服务器)") + + status_text = "\n".join(lines) + + if "status" not in self.config: + self.config["status"] = {} + self.config["status"]["connection_status"] = status_text + + def get_plugin_components(self) -> List[Tuple[ComponentInfo, Type]]: + """返回插件的所有组件""" + components: List[Tuple[ComponentInfo, Type]] = [] + + # 事件处理器 + components.append((MCPStartupHandler.get_handler_info(), MCPStartupHandler)) + components.append((MCPStopHandler.get_handler_info(), MCPStopHandler)) + + # 命令 + components.append((MCPStatusCommand.get_command_info(), MCPStatusCommand)) + components.append((MCPImportCommand.get_command_info(), MCPImportCommand)) + + # 内置工具 + status_tool_info = ToolInfo( + name=MCPStatusTool.name, + tool_description=MCPStatusTool.description, + enabled=True, + tool_parameters=MCPStatusTool.parameters, + component_type=ComponentType.TOOL, + ) + components.append((status_tool_info, MCPStatusTool)) + + settings = self.config.get("settings", {}) + + if settings.get("enable_resources", False): + read_resource_info = ToolInfo( + name=MCPReadResourceTool.name, + tool_description=MCPReadResourceTool.description, + enabled=True, + tool_parameters=MCPReadResourceTool.parameters, + component_type=ComponentType.TOOL, + ) + components.append((read_resource_info, MCPReadResourceTool)) + + if settings.get("enable_prompts", False): + get_prompt_info = ToolInfo( + name=MCPGetPromptTool.name, + tool_description=MCPGetPromptTool.description, + enabled=True, + tool_parameters=MCPGetPromptTool.parameters, + component_type=ComponentType.TOOL, + ) + components.append((get_prompt_info, MCPGetPromptTool)) + + return components + + def get_status(self) -> Dict[str, Any]: + """获取插件状态""" + return { + "initialized": self._initialized, + "mcp_manager": mcp_manager.get_status(), + "registered_tools": len(mcp_tool_registry._tool_classes), + "trace_records": tool_call_tracer.total_records, + "cache_stats": tool_call_cache.get_stats(), + } + + def get_stats(self) -> Dict[str, Any]: + """获取详细统计信息""" + return mcp_manager.get_all_stats() diff --git a/plugins/MaiBot_MCPBridgePlugin/requirements.txt b/plugins/MaiBot_MCPBridgePlugin/requirements.txt new file mode 100644 index 00000000..7580f09e --- /dev/null +++ b/plugins/MaiBot_MCPBridgePlugin/requirements.txt @@ -0,0 +1,2 @@ +# MCP 桥接插件依赖 +mcp>=1.0.0 diff --git a/plugins/MaiBot_MCPBridgePlugin/tool_chain.py b/plugins/MaiBot_MCPBridgePlugin/tool_chain.py new file mode 100644 index 00000000..2be515f1 --- /dev/null +++ b/plugins/MaiBot_MCPBridgePlugin/tool_chain.py @@ -0,0 +1,582 @@ +""" +MCP Workflow 模块 v1.9.0 +支持用户自定义工作流（硬流程），将多个 MCP 工具按顺序执行 + +双轨制架构: +- 软流程 (ReAct): LLM 自主决策，动态多轮调用工具，灵活但不可预测 +- 硬流程 (Workflow): 用户预定义的工作流，固定流程，可靠可控 + +功能: +- Workflow 定义和管理 +- 顺序执行多个工具（硬流程） +- 支持变量替换（使用前序工具的输出） +- 自动注册为组合工具供 LLM 调用 +- 与 ReAct 软流程互补，用户可选择合适的执行方式 +""" + +import asyncio +import json +import re +import time +from dataclasses import dataclass, field +from typing import Any, Dict, List, Optional, Tuple, Type + +try: + from src.common.logger import get_logger + logger = get_logger("mcp_tool_chain") +except ImportError: + import logging + logger = logging.getLogger("mcp_tool_chain") + + +@dataclass +class ToolChainStep: + """工具链步骤""" + tool_name: str # 要调用的工具名（如 mcp_server_tool） + args_template: Dict[str, Any] = field(default_factory=dict) # 参数模板，支持变量替换 + output_key: str = "" # 输出存储的键名，供后续步骤引用 + description: str = "" # 步骤描述 + optional: bool = False # 是否可选（失败时继续执行） + + def to_dict(self) -> Dict[str, Any]: + return { + "tool_name": self.tool_name, + "args_template": self.args_template, + "output_key": self.output_key, + "description": self.description, + "optional": self.optional, + } + + @classmethod + def from_dict(cls, data: Dict[str, Any]) -> "ToolChainStep": + return cls( + tool_name=data.get("tool_name", ""), + args_template=data.get("args_template", {}), + output_key=data.get("output_key", ""), + description=data.get("description", ""), + optional=data.get("optional", False), + ) + + +@dataclass +class ToolChainDefinition: + """工具链定义""" + name: str # 工具链名称（将作为组合工具的名称） + description: str # 工具链描述（供 LLM 理解） + steps: List[ToolChainStep] = field(default_factory=list) # 执行步骤 + input_params: Dict[str, str] = field(default_factory=dict) # 输入参数定义 {参数名: 描述} + enabled: bool = True # 是否启用 + + def to_dict(self) -> Dict[str, Any]: + return { + "name": self.name, + "description": self.description, + "steps": [step.to_dict() for step in self.steps], + "input_params": self.input_params, + "enabled": self.enabled, + } + + @classmethod + def from_dict(cls, data: Dict[str, Any]) -> "ToolChainDefinition": + steps = [ToolChainStep.from_dict(s) for s in data.get("steps", [])] + return cls( + name=data.get("name", ""), + description=data.get("description", ""), + steps=steps, + input_params=data.get("input_params", {}), + enabled=data.get("enabled", True), + ) + + +@dataclass +class ChainExecutionResult: + """工具链执行结果""" + success: bool + final_output: str # 最终输出（最后一个步骤的结果） + step_results: List[Dict[str, Any]] = field(default_factory=list) # 每个步骤的结果 + error: str = "" + total_duration_ms: float = 0.0 + + def to_summary(self) -> str: + """生成执行摘要""" + lines = [] + for i, step in enumerate(self.step_results): + status = "✅" if step.get("success") else "❌" + tool = step.get("tool_name", "unknown") + duration = step.get("duration_ms", 0) + lines.append(f"{status} 步骤{i+1}: {tool} ({duration:.0f}ms)") + if not step.get("success") and step.get("error"): + lines.append(f" 错误: {step['error'][:50]}") + return "\n".join(lines) + + +class ToolChainExecutor: + """工具链执行器""" + + # 变量替换模式: ${step.output_key} 或 ${input.param_name} 或 ${prev} + VAR_PATTERN = re.compile(r'\$\{([^}]+)\}') + + def __init__(self, mcp_manager): + self._mcp_manager = mcp_manager + + def _resolve_tool_key(self, tool_name: str) -> Optional[str]: + """解析工具名，返回有效的 tool_key + + 支持: + - 直接使用 tool_key（如 mcp_server_tool） + - 使用注册后的工具名（会自动转换 - 和 . 为 _） + """ + all_tools = self._mcp_manager.all_tools + + # 直接匹配 + if tool_name in all_tools: + return tool_name + + # 尝试转换后匹配（用户可能使用了注册后的名称） + normalized = tool_name.replace("-", "_").replace(".", "_") + if normalized in all_tools: + return normalized + + # 尝试查找包含该名称的工具 + for key in all_tools.keys(): + if key.endswith(f"_{tool_name}") or key.endswith(f"_{normalized}"): + return key + + return None + + async def execute( + self, + chain: ToolChainDefinition, + input_args: Dict[str, Any], + ) -> ChainExecutionResult: + """执行工具链 + + Args: + chain: 工具链定义 + input_args: 用户输入的参数 + + Returns: + ChainExecutionResult: 执行结果 + """ + start_time = time.time() + step_results = [] + context = { + "input": input_args or {}, # 用户输入，确保不为 None + "step": {}, # 各步骤输出，按 output_key 存储 + "prev": "", # 上一步的输出 + } + + final_output = "" + + # 验证必需的输入参数 + missing_params = [] + for param_name in chain.input_params.keys(): + if param_name not in context["input"]: + missing_params.append(param_name) + + if missing_params: + return ChainExecutionResult( + success=False, + final_output="", + error=f"缺少必需参数: {', '.join(missing_params)}", + total_duration_ms=(time.time() - start_time) * 1000, + ) + + for i, step in enumerate(chain.steps): + step_start = time.time() + step_result = { + "step_index": i, + "tool_name": step.tool_name, + "success": False, + "output": "", + "error": "", + "duration_ms": 0, + } + + try: + # 替换参数中的变量 + resolved_args = self._resolve_args(step.args_template, context) + step_result["resolved_args"] = resolved_args + + # 解析工具名 + tool_key = self._resolve_tool_key(step.tool_name) + if not tool_key: + step_result["error"] = f"工具 {step.tool_name} 不存在" + logger.warning(f"工具链步骤 {i+1}: 工具 {step.tool_name} 不存在") + + if not step.optional: + step_results.append(step_result) + return ChainExecutionResult( + success=False, + final_output="", + step_results=step_results, + error=f"步骤 {i+1}: 工具 {step.tool_name} 不存在", + total_duration_ms=(time.time() - start_time) * 1000, + ) + step_results.append(step_result) + continue + + logger.debug(f"工具链步骤 {i+1}: 调用 {tool_key}，参数: {resolved_args}") + + # 调用工具 + result = await self._mcp_manager.call_tool(tool_key, resolved_args) + + step_duration = (time.time() - step_start) * 1000 + step_result["duration_ms"] = step_duration + + if result.success: + step_result["success"] = True + # 确保 content 不为 None + content = result.content if result.content is not None else "" + step_result["output"] = content + + # 更新上下文 + context["prev"] = content + if step.output_key: + context["step"][step.output_key] = content + + final_output = content + content_preview = content[:100] if content else "(空)" + logger.debug(f"工具链步骤 {i+1} 成功: {content_preview}...") + else: + step_result["error"] = result.error or "未知错误" + logger.warning(f"工具链步骤 {i+1} 失败: {result.error}") + + if not step.optional: + step_results.append(step_result) + return ChainExecutionResult( + success=False, + final_output="", + step_results=step_results, + error=f"步骤 {i+1} ({step.tool_name}) 失败: {result.error}", + total_duration_ms=(time.time() - start_time) * 1000, + ) + + except Exception as e: + step_duration = (time.time() - step_start) * 1000 + step_result["duration_ms"] = step_duration + step_result["error"] = str(e) + logger.error(f"工具链步骤 {i+1} 异常: {e}") + + if not step.optional: + step_results.append(step_result) + return ChainExecutionResult( + success=False, + final_output="", + step_results=step_results, + error=f"步骤 {i+1} ({step.tool_name}) 异常: {e}", + total_duration_ms=(time.time() - start_time) * 1000, + ) + + step_results.append(step_result) + + total_duration = (time.time() - start_time) * 1000 + + return ChainExecutionResult( + success=True, + final_output=final_output, + step_results=step_results, + total_duration_ms=total_duration, + ) + + def _resolve_args(self, args_template: Dict[str, Any], context: Dict[str, Any]) -> Dict[str, Any]: + """解析参数模板，替换变量 + + 支持的变量格式: + - ${input.param_name}: 用户输入的参数 + - ${step.output_key}: 某个步骤的输出 + - ${prev}: 上一步的输出 + - ${prev.field}: 上一步输出（JSON）的某个字段 + """ + resolved = {} + + for key, value in args_template.items(): + if isinstance(value, str): + resolved[key] = self._substitute_vars(value, context) + elif isinstance(value, dict): + resolved[key] = self._resolve_args(value, context) + elif isinstance(value, list): + resolved[key] = [ + self._substitute_vars(v, context) if isinstance(v, str) else v + for v in value + ] + else: + resolved[key] = value + + return resolved + + def _substitute_vars(self, template: str, context: Dict[str, Any]) -> str: + """替换字符串中的变量""" + def replacer(match): + var_path = match.group(1) + return self._get_var_value(var_path, context) + + return self.VAR_PATTERN.sub(replacer, template) + + def _get_var_value(self, var_path: str, context: Dict[str, Any]) -> str: + """获取变量值 + + Args: + var_path: 变量路径，如 "input.query", "step.search_result", "prev", "prev.id" + context: 上下文 + """ + parts = self._parse_var_path(var_path) + + if not parts: + return "" + + # 获取根对象 + root = parts[0] + if root not in context: + logger.warning(f"变量 {var_path} 的根 '{root}' 不存在") + return "" + + value = context[root] + + # 遍历路径 + for part in parts[1:]: + if isinstance(value, str): + parsed = self._try_parse_json(value) + if parsed is not None: + value = parsed + + if isinstance(value, dict): + value = value.get(part, "") + elif isinstance(value, list): + if part.isdigit(): + idx = int(part) + value = value[idx] if 0 <= idx < len(value) else "" + else: + value = "" + else: + value = "" + + # 确保返回字符串 + if isinstance(value, (dict, list)): + return json.dumps(value, ensure_ascii=False) + if value is None: + return "" + if value == "": + return "" + return str(value) + + def _try_parse_json(self, value: str) -> Optional[Any]: + """尝试将字符串解析为 JSON 对象，失败则返回 None。""" + if not value: + return None + try: + return json.loads(value) + except json.JSONDecodeError: + return None + + def _parse_var_path(self, var_path: str) -> List[str]: + """解析变量路径，支持点号与下标写法。 + + 支持: + - step.geo.return.0.location + - step.geo.return[0].location + - step.geo['return'][0]['location'] + """ + if not var_path: + return [] + + tokens: List[str] = [] + buf: List[str] = [] + in_bracket = False + in_quote = False + quote_char = "" + + def flush_buf() -> None: + if buf: + token = "".join(buf).strip() + if token: + tokens.append(token) + buf.clear() + + i = 0 + while i < len(var_path): + ch = var_path[i] + + if not in_bracket and ch == ".": + flush_buf() + i += 1 + continue + + if not in_bracket and ch == "[": + flush_buf() + in_bracket = True + in_quote = False + quote_char = "" + i += 1 + continue + + if in_bracket and not in_quote and ch == "]": + flush_buf() + in_bracket = False + i += 1 + continue + + if in_bracket and ch in ("'", '"'): + if not in_quote: + in_quote = True + quote_char = ch + i += 1 + continue + if quote_char == ch: + in_quote = False + quote_char = "" + i += 1 + continue + + if in_bracket and not in_quote: + if ch.isspace(): + i += 1 + continue + if ch == ",": + i += 1 + continue + + buf.append(ch) + i += 1 + + flush_buf() + + if in_bracket or in_quote: + return [p for p in var_path.split(".") if p] + + return tokens + + +class ToolChainManager: + """工具链管理器""" + + _instance: Optional["ToolChainManager"] = None + + def __new__(cls): + if cls._instance is None: + cls._instance = super().__new__(cls) + cls._instance._initialized = False + return cls._instance + + def __init__(self): + if self._initialized: + return + self._initialized = True + self._chains: Dict[str, ToolChainDefinition] = {} + self._executor: Optional[ToolChainExecutor] = None + + def set_executor(self, mcp_manager) -> None: + """设置执行器""" + self._executor = ToolChainExecutor(mcp_manager) + + def add_chain(self, chain: ToolChainDefinition) -> bool: + """添加工具链""" + if not chain.name: + logger.error("工具链名称不能为空") + return False + + if chain.name in self._chains: + logger.warning(f"工具链 {chain.name} 已存在，将被覆盖") + + self._chains[chain.name] = chain + logger.info(f"已添加工具链: {chain.name} ({len(chain.steps)} 个步骤)") + return True + + def remove_chain(self, name: str) -> bool: + """移除工具链""" + if name in self._chains: + del self._chains[name] + logger.info(f"已移除工具链: {name}") + return True + return False + + def get_chain(self, name: str) -> Optional[ToolChainDefinition]: + """获取工具链""" + return self._chains.get(name) + + def get_all_chains(self) -> Dict[str, ToolChainDefinition]: + """获取所有工具链""" + return self._chains.copy() + + def get_enabled_chains(self) -> Dict[str, ToolChainDefinition]: + """获取所有启用的工具链""" + return {name: chain for name, chain in self._chains.items() if chain.enabled} + + async def execute_chain( + self, + chain_name: str, + input_args: Dict[str, Any], + ) -> ChainExecutionResult: + """执行工具链""" + chain = self._chains.get(chain_name) + if not chain: + return ChainExecutionResult( + success=False, + final_output="", + error=f"工具链 {chain_name} 不存在", + ) + + if not chain.enabled: + return ChainExecutionResult( + success=False, + final_output="", + error=f"工具链 {chain_name} 已禁用", + ) + + if not self._executor: + return ChainExecutionResult( + success=False, + final_output="", + error="工具链执行器未初始化", + ) + + return await self._executor.execute(chain, input_args) + + def load_from_json(self, json_str: str) -> Tuple[int, List[str]]: + """从 JSON 字符串加载工具链配置 + + Returns: + (成功加载数量, 错误列表) + """ + errors = [] + loaded = 0 + + try: + data = json.loads(json_str) if json_str.strip() else [] + except json.JSONDecodeError as e: + return 0, [f"JSON 解析失败: {e}"] + + if not isinstance(data, list): + data = [data] + + for i, item in enumerate(data): + try: + chain = ToolChainDefinition.from_dict(item) + if not chain.name: + errors.append(f"第 {i+1} 个工具链缺少名称") + continue + if not chain.steps: + errors.append(f"工具链 {chain.name} 没有步骤") + continue + + self.add_chain(chain) + loaded += 1 + except Exception as e: + errors.append(f"第 {i+1} 个工具链解析失败: {e}") + + return loaded, errors + + def export_to_json(self, pretty: bool = True) -> str: + """导出所有工具链为 JSON""" + chains_data = [chain.to_dict() for chain in self._chains.values()] + if pretty: + return json.dumps(chains_data, ensure_ascii=False, indent=2) + return json.dumps(chains_data, ensure_ascii=False) + + def clear(self) -> None: + """清空所有工具链""" + self._chains.clear() + + +# 全局工具链管理器实例 +tool_chain_manager = ToolChainManager() diff --git a/plugins/emoji_manage_plugin/_manifest.json b/plugins/emoji_manage_plugin/_manifest.json index ee8d8318..68f5c679 100644 --- a/plugins/emoji_manage_plugin/_manifest.json +++ b/plugins/emoji_manage_plugin/_manifest.json @@ -8,18 +8,22 @@ "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"], - + "keywords": [ + "emoji", + "manage", + "plugin" + ], + "categories": [ + "Examples", + "Tutorial" + ], "default_locale": "zh-CN", "locales_path": "_locales", - "plugin_info": { "is_built_in": false, "plugin_type": "emoji_manage", @@ -31,10 +35,17 @@ }, { "type": "action", - "name": "bye_greeting", + "name": "bye_greeting", "description": "向用户发送告别消息", - "activation_modes": ["keyword"], - "keywords": ["再见", "bye", "88", "拜拜"] + "activation_modes": [ + "keyword" + ], + "keywords": [ + "再见", + "bye", + "88", + "拜拜" + ] }, { "type": "command", @@ -49,5 +60,6 @@ "配置文件示例", "新手教程代码" ] - } + }, + "id": "SengokuCola.BetterEmoji" } \ No newline at end of file diff --git a/plugins/hello_world_plugin/_manifest.json b/plugins/hello_world_plugin/_manifest.json index b1a4c4eb..25234a00 100644 --- a/plugins/hello_world_plugin/_manifest.json +++ b/plugins/hello_world_plugin/_manifest.json @@ -8,18 +8,24 @@ "url": "https://github.com/MaiM-with-u" }, "license": "GPL-v3.0-or-later", - "host_application": { "min_version": "0.8.0" }, "homepage_url": "https://github.com/MaiM-with-u/maibot", "repository_url": "https://github.com/MaiM-with-u/maibot", - "keywords": ["demo", "example", "hello", "greeting", "tutorial"], - "categories": ["Examples", "Tutorial"], - + "keywords": [ + "demo", + "example", + "hello", + "greeting", + "tutorial" + ], + "categories": [ + "Examples", + "Tutorial" + ], "default_locale": "zh-CN", "locales_path": "_locales", - "plugin_info": { "is_built_in": false, "plugin_type": "example", @@ -31,10 +37,17 @@ }, { "type": "action", - "name": "bye_greeting", + "name": "bye_greeting", "description": "向用户发送告别消息", - "activation_modes": ["keyword"], - "keywords": ["再见", "bye", "88", "拜拜"] + "activation_modes": [ + "keyword" + ], + "keywords": [ + "再见", + "bye", + "88", + "拜拜" + ] }, { "type": "command", @@ -49,5 +62,6 @@ "配置文件示例", "新手教程代码" ] - } + }, + "id": "MaiBot开发团队.maibot" } \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index fb613e19..85dd74e3 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "MaiBot" -version = "0.11.0" +version = "0.11.6" description = "MaiCore 是一个基于大语言模型的可交互智能体" requires-python = ">=3.10" dependencies = [ @@ -14,6 +14,7 @@ dependencies = [ "json-repair>=0.47.6", "maim-message", "matplotlib>=3.10.3", + "msgpack>=1.1.2", "numpy>=2.2.6", "openai>=1.95.0", "pandas>=2.3.1", @@ -23,6 +24,7 @@ dependencies = [ "pydantic>=2.11.7", "pypinyin>=0.54.0", "python-dotenv>=1.1.1", + "python-multipart>=0.0.20", "quick-algo>=0.1.3", "rich>=14.0.0", "ruff>=0.12.2", @@ -32,9 +34,14 @@ dependencies = [ "tomlkit>=0.13.3", "urllib3>=2.5.0", "uvicorn>=0.35.0", + "zstandard>=0.25.0", ] +[tool.uv] +index-url = "https://pypi.tuna.tsinghua.edu.cn/simple" + + [tool.ruff] include = ["*.py"] diff --git a/requirements.txt b/requirements.txt index 8a0d22c2..56c944e8 100644 --- a/requirements.txt +++ b/requirements.txt @@ -17,6 +17,7 @@ pyarrow>=20.0.0 pydantic>=2.11.7 pypinyin>=0.54.0 python-dotenv>=1.1.1 +python-multipart>=0.0.20 quick-algo>=0.1.3 rich>=14.0.0 ruff>=0.12.2 diff --git a/scripts/delete_lpmm_items.py b/scripts/delete_lpmm_items.py new file mode 100644 index 00000000..2eb37ded --- /dev/null +++ b/scripts/delete_lpmm_items.py @@ -0,0 +1,386 @@ +import argparse +import sys +from pathlib import Path +from typing import List, Tuple, Dict, Any +import json +import os + +# 强制使用 utf-8，避免控制台编码报错 +try: + if hasattr(sys.stdout, "reconfigure"): + sys.stdout.reconfigure(encoding="utf-8") + if hasattr(sys.stderr, "reconfigure"): + sys.stderr.reconfigure(encoding="utf-8") +except Exception: + pass + +# 确保能找到 src 包 +sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))) + +from src.chat.knowledge.embedding_store import EmbeddingManager +from src.chat.knowledge.kg_manager import KGManager +from src.common.logger import get_logger +from src.chat.knowledge.utils.hash import get_sha256 + +logger = get_logger("delete_lpmm_items") + + +def read_hashes(file_path: Path) -> List[str]: + """读取哈希列表，跳过空行""" + hashes: List[str] = [] + for line in file_path.read_text(encoding="utf-8").splitlines(): + val = line.strip() + if not val: + continue + hashes.append(val) + return hashes + + +def read_openie_hashes(file_path: Path) -> List[str]: + """从 OpenIE JSON 中提取 idx 作为段落哈希""" + data: Dict[str, Any] = json.loads(file_path.read_text(encoding="utf-8")) + docs = data.get("docs", []) if isinstance(data, dict) else [] + hashes: List[str] = [] + for doc in docs: + idx = doc.get("idx") if isinstance(doc, dict) else None + if isinstance(idx, str) and idx.strip(): + hashes.append(idx.strip()) + return hashes + + +def normalize_paragraph_keys(raw_hashes: List[str]) -> Tuple[List[str], List[str]]: + """将输入规范为完整键和纯哈希两份列表""" + keys: List[str] = [] + hashes: List[str] = [] + for h in raw_hashes: + if h.startswith("paragraph-"): + keys.append(h) + hashes.append(h.replace("paragraph-", "", 1)) + else: + keys.append(f"paragraph-{h}") + hashes.append(h) + return keys, hashes + + +def main(): + parser = argparse.ArgumentParser(description="Delete paragraphs from LPMM knowledge base (vectors + graph).") + parser.add_argument("--hash-file", help="文本文件路径，每行一个 paragraph 哈希或带前缀键") + parser.add_argument("--openie-file", help="OpenIE 输出文件（JSON），将其 docs.idx 作为待删段落哈希") + parser.add_argument("--raw-file", help="原始 txt 语料文件（按空行分段），可结合 --raw-index 使用") + parser.add_argument( + "--raw-index", + help="在 --raw-file 中要删除的段落索引，1 基，支持逗号分隔，例如 1,3", + ) + parser.add_argument("--search-text", help="在当前段落库中按子串搜索匹配段落并交互选择删除") + parser.add_argument( + "--search-limit", + type=int, + default=10, + help="--search-text 模式下最多展示的候选段落数量", + ) + parser.add_argument("--delete-entities", action="store_true", help="同时删除 OpenIE 文件中的实体节点/嵌入") + parser.add_argument("--delete-relations", action="store_true", help="同时删除 OpenIE 文件中的关系嵌入") + parser.add_argument("--remove-orphan-entities", action="store_true", help="删除删除后孤立的实体节点") + parser.add_argument("--dry-run", action="store_true", help="仅预览将删除的项，不实际修改") + parser.add_argument("--yes", action="store_true", help="跳过交互确认，直接执行删除（谨慎使用）") + parser.add_argument( + "--max-delete-nodes", + type=int, + default=2000, + help="单次最大允许删除的节点数量（段落+实体），超过则需要显式确认或调整该参数", + ) + parser.add_argument( + "--non-interactive", + action="store_true", + help=( + "非交互模式：不再通过 input() 询问任何信息；" + "在该模式下，如果需要交互（例如 --search-text 未指定具体条目、未提供 --yes），" + "会直接报错退出。" + ), + ) + args = parser.parse_args() + + # 至少需要一种来源 + if not (args.hash_file or args.openie_file or args.raw_file or args.search_text): + logger.error("必须指定 --hash-file / --openie-file / --raw-file / --search-text 之一") + sys.exit(1) + + raw_hashes: List[str] = [] + raw_entities: List[str] = [] + raw_relations: List[str] = [] + + if args.hash_file: + hash_file = Path(args.hash_file) + if not hash_file.exists(): + logger.error(f"哈希文件不存在: {hash_file}") + sys.exit(1) + raw_hashes.extend(read_hashes(hash_file)) + + if args.openie_file: + openie_path = Path(args.openie_file) + if not openie_path.exists(): + logger.error(f"OpenIE 文件不存在: {openie_path}") + sys.exit(1) + # 段落 + raw_hashes.extend(read_openie_hashes(openie_path)) + # 实体/关系（实体同时包含 extracted_entities 与三元组主语/宾语，以匹配 KG 构图逻辑） + try: + data = json.loads(openie_path.read_text(encoding="utf-8")) + docs = data.get("docs", []) if isinstance(data, dict) else [] + for doc in docs: + if not isinstance(doc, dict): + continue + ents = doc.get("extracted_entities", []) + if isinstance(ents, list): + raw_entities.extend([e for e in ents if isinstance(e, str)]) + triples = doc.get("extracted_triples", []) + if isinstance(triples, list): + for t in triples: + if isinstance(t, list) and len(t) == 3: + subj, _, obj = t + if isinstance(subj, str): + raw_entities.append(subj) + if isinstance(obj, str): + raw_entities.append(obj) + raw_relations.append(str(tuple(t))) + except Exception as e: + logger.error(f"读取 OpenIE 文件失败: {e}") + sys.exit(1) + + # 从原始 txt 语料按段落索引选择删除 + if args.raw_file: + raw_path = Path(args.raw_file) + if not raw_path.exists(): + logger.error(f"原始语料文件不存在: {raw_path}") + sys.exit(1) + text = raw_path.read_text(encoding="utf-8") + paragraphs: List[str] = [] + buf = [] + for line in text.splitlines(): + if line.strip() == "": + if buf: + paragraphs.append("\n".join(buf).strip()) + buf = [] + else: + buf.append(line) + if buf: + paragraphs.append("\n".join(buf).strip()) + + if not paragraphs: + logger.error(f"原始语料文件 {raw_path} 中没有解析到任何段落") + sys.exit(1) + + if not args.raw_index: + logger.info(f"{raw_path} 共解析出 {len(paragraphs)} 个段落，请通过 --raw-index 指定要删除的段落，例如 --raw-index 1,3") + sys.exit(1) + + # 解析索引列表（1-based） + try: + idx_list = [int(x.strip()) for x in str(args.raw_index).split(",") if x.strip()] + except ValueError: + logger.error(f"--raw-index 解析失败: {args.raw_index}") + sys.exit(1) + + for idx in idx_list: + if idx < 1 or idx > len(paragraphs): + logger.error(f"--raw-index 包含无效索引 {idx}（有效范围 1~{len(paragraphs)}）") + sys.exit(1) + + logger.info("根据原始语料选择段落：") + for idx in idx_list: + para = paragraphs[idx - 1] + h = get_sha256(para) + logger.info(f"- 第 {idx} 段，hash={h}，内容预览：{para[:80]}") + raw_hashes.append(h) + + # 在现有库中按子串搜索候选段落并交互选择 + if args.search_text: + search_text = args.search_text.strip() + if not search_text: + logger.error("--search-text 不能为空") + sys.exit(1) + logger.info(f"正在根据关键字在现有段落库中搜索：{search_text!r}") + em_search = EmbeddingManager() + try: + em_search.load_from_file() + except Exception as e: + logger.error(f"加载嵌入库失败，无法使用 --search-text 功能: {e}") + sys.exit(1) + + candidates = [] + for key, item in em_search.paragraphs_embedding_store.store.items(): + if search_text in item.str: + candidates.append((key, item.str)) + if len(candidates) >= args.search_limit: + break + + if not candidates: + logger.info("未在现有段落库中找到包含该关键字的段落") + else: + logger.info("找到以下候选段落（输入序号选择要删除的条目，可用逗号分隔，多选）：") + for i, (key, text) in enumerate(candidates, start=1): + logger.info(f"{i}. {key} | {text[:80]}") + if args.non_interactive: + logger.error( + "当前处于非交互模式，无法通过输入序号选择要删除的候选段落；" + "如需脚本化删除，请改用 --hash-file / --openie-file / --raw-file 等方式。" + ) + sys.exit(1) + choice = input("请输入要删除的序号列表（如 1,3），或直接回车取消：").strip() + if choice: + try: + idxs = [int(x.strip()) for x in choice.split(",") if x.strip()] + except ValueError: + logger.error("输入的序号列表无法解析，已取消 --search-text 删除") + else: + for i in idxs: + if 1 <= i <= len(candidates): + key, _ = candidates[i - 1] + # key 已是完整的 paragraph-xxx + if key.startswith("paragraph-"): + raw_hashes.append(key.split("paragraph-", 1)[1]) + else: + logger.warning(f"忽略无效序号: {i}") + + # 去重但保持顺序 + seen = set() + raw_hashes = [h for h in raw_hashes if not (h in seen or seen.add(h))] + + if not raw_hashes: + logger.error("未读取到任何待删哈希，无操作") + sys.exit(1) + + keys, pg_hashes = normalize_paragraph_keys(raw_hashes) + + ent_hashes: List[str] = [] + rel_hashes: List[str] = [] + if args.delete_entities and raw_entities: + ent_hashes = [get_sha256(e) for e in raw_entities] + if args.delete_relations and raw_relations: + rel_hashes = [get_sha256(r) for r in raw_relations] + + logger.info("=== 删除操作预备 ===") + logger.info("请确保已备份 data/embedding 与 data/rag，必要时可使用 --dry-run 预览") + logger.info(f"待删除段落数量: {len(keys)}") + logger.info(f"示例: {keys[:5]}") + if ent_hashes: + logger.info(f"待删除实体数量: {len(ent_hashes)}") + if rel_hashes: + logger.info(f"待删除关系数量: {len(rel_hashes)}") + + total_nodes_to_delete = len(pg_hashes) + (len(ent_hashes) if args.delete_entities else 0) + logger.info(f"本次预计删除节点总数（段落+实体）: {total_nodes_to_delete}") + + if args.dry_run: + logger.info("dry-run 模式，未执行删除") + return + + # 大批次删除保护 + if total_nodes_to_delete > args.max_delete_nodes and not args.yes: + logger.error( + f"本次预计删除节点 {total_nodes_to_delete} 个，超过阈值 {args.max_delete_nodes}。" + " 为避免误删，请降低批次规模或使用 --max-delete-nodes 调整阈值，并加上 --yes 明确确认。" + ) + sys.exit(1) + + # 交互确认 + if not args.yes: + if args.non_interactive: + logger.error( + "当前处于非交互模式且未指定 --yes，出于安全考虑，删除操作已被拒绝。\n" + "如确认需要在非交互模式下执行删除，请显式添加 --yes 参数。" + ) + sys.exit(1) + confirm = input("确认删除上述数据？输入大写 YES 以继续，其他任意键取消: ").strip() + if confirm != "YES": + logger.info("用户取消删除操作") + return + + # 加载嵌入与图 + embed_manager = EmbeddingManager() + kg_manager = KGManager() + + try: + embed_manager.load_from_file() + kg_manager.load_from_file() + except Exception as e: + logger.error(f"加载现有知识库失败: {e}") + sys.exit(1) + + # 记录删除前全局统计，便于对比 + before_para_vec = len(embed_manager.paragraphs_embedding_store.store) + before_ent_vec = len(embed_manager.entities_embedding_store.store) + before_rel_vec = len(embed_manager.relation_embedding_store.store) + before_nodes = len(kg_manager.graph.get_node_list()) + before_edges = len(kg_manager.graph.get_edge_list()) + logger.info( + f"删除前统计: 段落向量={before_para_vec}, 实体向量={before_ent_vec}, 关系向量={before_rel_vec}, " + f"KG节点={before_nodes}, KG边={before_edges}" + ) + + # 删除向量 + deleted, skipped = embed_manager.paragraphs_embedding_store.delete_items(keys) + embed_manager.stored_pg_hashes = set(embed_manager.paragraphs_embedding_store.store.keys()) + logger.info(f"段落向量删除完成，删除: {deleted}, 跳过: {skipped}") + ent_deleted = ent_skipped = rel_deleted = rel_skipped = 0 + if ent_hashes: + ent_keys = [f"entity-{h}" for h in ent_hashes] + ent_deleted, ent_skipped = embed_manager.entities_embedding_store.delete_items(ent_keys) + logger.info(f"实体向量删除完成，删除: {ent_deleted}, 跳过: {ent_skipped}") + if rel_hashes: + rel_keys = [f"relation-{h}" for h in rel_hashes] + rel_deleted, rel_skipped = embed_manager.relation_embedding_store.delete_items(rel_keys) + logger.info(f"关系向量删除完成，删除: {rel_deleted}, 跳过: {rel_skipped}") + + # 删除图节点/边 + kg_result = kg_manager.delete_paragraphs( + pg_hashes, + ent_hashes=ent_hashes if args.delete_entities else None, + remove_orphan_entities=args.remove_orphan_entities, + ) + logger.info( + f"KG 删除完成，删除: {kg_result.get('deleted', 0)}, 跳过: {kg_result.get('skipped', 0)}, " + f"孤立实体清理: {kg_result.get('orphan_removed', 0)}" + ) + + # 重建索引并保存 + logger.info("重建 Faiss 索引并保存嵌入文件...") + embed_manager.rebuild_faiss_index() + embed_manager.save_to_file() + + logger.info("保存 KG 数据...") + kg_manager.save_to_file() + + # 删除后统计 + after_para_vec = len(embed_manager.paragraphs_embedding_store.store) + after_ent_vec = len(embed_manager.entities_embedding_store.store) + after_rel_vec = len(embed_manager.relation_embedding_store.store) + after_nodes = len(kg_manager.graph.get_node_list()) + after_edges = len(kg_manager.graph.get_edge_list()) + + logger.info( + "删除后统计: 段落向量=%d(%+d), 实体向量=%d(%+d), 关系向量=%d(%+d), KG节点=%d(%+d), KG边=%d(%+d)" + % ( + after_para_vec, + after_para_vec - before_para_vec, + after_ent_vec, + after_ent_vec - before_ent_vec, + after_rel_vec, + after_rel_vec - before_rel_vec, + after_nodes, + after_nodes - before_nodes, + after_edges, + after_edges - before_edges, + ) + ) + + logger.info("删除流程完成") + print( + "\n[NOTICE] 删除脚本执行完毕。如主程序（聊天 / WebUI）已在运行，" + "请重启主程序，或在主程序内部调用一次 lpmm_start_up() 以应用最新 LPMM 知识库。" + ) + print("[NOTICE] 如果不清楚 lpmm_start_up 是什么，直接重启主程序即可。") + + +if __name__ == "__main__": + main() diff --git a/scripts/expression_merge_simulation.py b/scripts/expression_merge_simulation.py new file mode 100644 index 00000000..4470e22f --- /dev/null +++ b/scripts/expression_merge_simulation.py @@ -0,0 +1,567 @@ +""" +模拟 Expression 合并过程 + +用法: + python scripts/expression_merge_simulation.py + 或指定 chat_id: + python scripts/expression_merge_simulation.py --chat-id + 或指定相似度阈值: + python scripts/expression_merge_simulation.py --similarity-threshold 0.8 +""" + +import sys +import os +import json +import argparse +import asyncio +import random +from typing import List, Dict, Tuple, Optional +from collections import defaultdict +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) + +# Import after setting up path (required for project imports) +from src.common.database.database_model import Expression, ChatStreams # noqa: E402 +from src.bw_learner.learner_utils import calculate_style_similarity # noqa: E402 +from src.llm_models.utils_model import LLMRequest # noqa: E402 +from src.config.config import model_config # noqa: E402 + + +def get_chat_name(chat_id: str) -> str: + """根据 chat_id 获取聊天名称""" + try: + chat_stream = ChatStreams.get_or_none(ChatStreams.stream_id == chat_id) + if chat_stream is None: + return f"未知聊天 ({chat_id[:8]}...)" + + if chat_stream.group_name: + return f"{chat_stream.group_name}" + elif chat_stream.user_nickname: + return f"{chat_stream.user_nickname}的私聊" + else: + return f"未知聊天 ({chat_id[:8]}...)" + except Exception: + return f"查询失败 ({chat_id[:8]}...)" + + +def parse_content_list(stored_list: Optional[str]) -> List[str]: + """解析 content_list JSON 字符串为列表""" + if not stored_list: + return [] + try: + data = json.loads(stored_list) + except json.JSONDecodeError: + return [] + return [str(item) for item in data if isinstance(item, str)] if isinstance(data, list) else [] + + +def parse_style_list(stored_list: Optional[str]) -> List[str]: + """解析 style_list JSON 字符串为列表""" + if not stored_list: + return [] + try: + data = json.loads(stored_list) + except json.JSONDecodeError: + return [] + return [str(item) for item in data if isinstance(item, str)] if isinstance(data, list) else [] + + +def find_exact_style_match( + expressions: List[Expression], + target_style: str, + chat_id: str, + exclude_ids: set +) -> Optional[Expression]: + """ + 查找具有完全匹配 style 的 Expression 记录 + 检查 style 字段和 style_list 中的每一项 + """ + for expr in expressions: + if expr.chat_id != chat_id or expr.id in exclude_ids: + continue + + # 检查 style 字段 + if expr.style == target_style: + return expr + + # 检查 style_list 中的每一项 + style_list = parse_style_list(expr.style_list) + if target_style in style_list: + return expr + + return None + + +def find_similar_style_expression( + expressions: List[Expression], + target_style: str, + chat_id: str, + similarity_threshold: float, + exclude_ids: set +) -> Optional[Tuple[Expression, float]]: + """ + 查找具有相似 style 的 Expression 记录 + 检查 style 字段和 style_list 中的每一项 + + Returns: + (Expression, similarity) 或 None + """ + best_match = None + best_similarity = 0.0 + + for expr in expressions: + if expr.chat_id != chat_id or expr.id in exclude_ids: + continue + + # 检查 style 字段 + similarity = calculate_style_similarity(target_style, expr.style) + if similarity >= similarity_threshold and similarity > best_similarity: + best_similarity = similarity + best_match = expr + + # 检查 style_list 中的每一项 + style_list = parse_style_list(expr.style_list) + for existing_style in style_list: + similarity = calculate_style_similarity(target_style, existing_style) + if similarity >= similarity_threshold and similarity > best_similarity: + best_similarity = similarity + best_match = expr + + if best_match: + return (best_match, best_similarity) + return None + + +async def compose_situation_text(content_list: List[str], summary_model: LLMRequest) -> str: + """组合 situation 文本，尝试使用 LLM 总结""" + sanitized = [c.strip() for c in content_list if c.strip()] + if not sanitized: + return "" + + if len(sanitized) == 1: + return sanitized[0] + + # 尝试使用 LLM 总结 + prompt = ( + "请阅读以下多个聊天情境描述，并将它们概括成一句简短的话，" + "长度不超过20个字，保留共同特点：\n" + f"{chr(10).join(f'- {s}' for s in sanitized[-10:])}\n只输出概括内容。" + ) + + try: + summary, _ = await summary_model.generate_response_async(prompt, temperature=0.2) + summary = summary.strip() + if summary: + return summary + except Exception as e: + print(f" ⚠️ LLM 总结 situation 失败: {e}") + + # 如果总结失败，返回用 "/" 连接的字符串 + return "/".join(sanitized) + + +async def compose_style_text(style_list: List[str], summary_model: LLMRequest) -> str: + """组合 style 文本，尝试使用 LLM 总结""" + sanitized = [s.strip() for s in style_list if s.strip()] + if not sanitized: + return "" + + if len(sanitized) == 1: + return sanitized[0] + + # 尝试使用 LLM 总结 + prompt = ( + "请阅读以下多个语言风格/表达方式，并将它们概括成一句简短的话，" + "长度不超过20个字，保留共同特点：\n" + f"{chr(10).join(f'- {s}' for s in sanitized[-10:])}\n只输出概括内容。" + ) + + try: + summary, _ = await summary_model.generate_response_async(prompt, temperature=0.2) + + print(f"Prompt:{prompt} Summary:{summary}") + + summary = summary.strip() + if summary: + return summary + except Exception as e: + print(f" ⚠️ LLM 总结 style 失败: {e}") + + # 如果总结失败，返回第一个 + return sanitized[0] + + +async def simulate_merge( + expressions: List[Expression], + similarity_threshold: float = 0.75, + use_llm: bool = False, + max_samples: int = 10, +) -> Dict: + """ + 模拟合并过程 + + Args: + expressions: Expression 列表（从数据库读出的原始记录） + similarity_threshold: style 相似度阈值 + use_llm: 是否使用 LLM 进行实际总结 + max_samples: 最多随机抽取的 Expression 数量（为 0 或 None 时表示不限制） + + Returns: + 包含合并统计信息的字典 + """ + # 如果样本太多，随机抽取一部分进行模拟，避免运行时间过长 + if max_samples and len(expressions) > max_samples: + expressions = random.sample(expressions, max_samples) + + # 按 chat_id 分组 + expressions_by_chat = defaultdict(list) + for expr in expressions: + expressions_by_chat[expr.chat_id].append(expr) + + # 初始化 LLM 模型（如果需要） + summary_model = None + if use_llm: + try: + summary_model = LLMRequest( + model_set=model_config.model_task_config.utils_small, + request_type="expression.summary" + ) + print("✅ LLM 模型已初始化，将进行实际总结") + except Exception as e: + print(f"⚠️ LLM 模型初始化失败: {e}，将跳过 LLM 总结") + use_llm = False + + merge_stats = { + "total_expressions": len(expressions), + "total_chats": len(expressions_by_chat), + "exact_matches": 0, + "similar_matches": 0, + "new_records": 0, + "merge_details": [], + "chat_stats": {}, + "use_llm": use_llm + } + + # 为每个 chat_id 模拟合并 + for chat_id, chat_expressions in expressions_by_chat.items(): + chat_name = get_chat_name(chat_id) + chat_stat = { + "chat_id": chat_id, + "chat_name": chat_name, + "total": len(chat_expressions), + "exact_matches": 0, + "similar_matches": 0, + "new_records": 0, + "merges": [] + } + + processed_ids = set() + + for expr in chat_expressions: + if expr.id in processed_ids: + continue + + target_style = expr.style + target_situation = expr.situation + + # 第一层：检查完全匹配 + exact_match = find_exact_style_match( + chat_expressions, + target_style, + chat_id, + {expr.id} + ) + + if exact_match: + # 完全匹配（不使用 LLM 总结） + # 模拟合并后的 content_list 和 style_list + target_content_list = parse_content_list(exact_match.content_list) + target_content_list.append(target_situation) + + target_style_list = parse_style_list(exact_match.style_list) + if exact_match.style and exact_match.style not in target_style_list: + target_style_list.append(exact_match.style) + if target_style not in target_style_list: + target_style_list.append(target_style) + + merge_info = { + "type": "exact", + "source_id": expr.id, + "target_id": exact_match.id, + "source_style": target_style, + "target_style": exact_match.style, + "source_situation": target_situation, + "target_situation": exact_match.situation, + "similarity": 1.0, + "merged_content_list": target_content_list, + "merged_style_list": target_style_list, + "merged_situation": exact_match.situation, # 完全匹配时保持原 situation + "merged_style": exact_match.style # 完全匹配时保持原 style + } + chat_stat["exact_matches"] += 1 + chat_stat["merges"].append(merge_info) + merge_stats["exact_matches"] += 1 + processed_ids.add(expr.id) + continue + + # 第二层：检查相似匹配 + similar_match = find_similar_style_expression( + chat_expressions, + target_style, + chat_id, + similarity_threshold, + {expr.id} + ) + + if similar_match: + match_expr, similarity = similar_match + # 相似匹配（使用 LLM 总结） + # 模拟合并后的 content_list 和 style_list + target_content_list = parse_content_list(match_expr.content_list) + target_content_list.append(target_situation) + + target_style_list = parse_style_list(match_expr.style_list) + if match_expr.style and match_expr.style not in target_style_list: + target_style_list.append(match_expr.style) + if target_style not in target_style_list: + target_style_list.append(target_style) + + # 使用 LLM 总结（如果启用） + merged_situation = match_expr.situation + merged_style = match_expr.style or target_style + + if use_llm and summary_model: + try: + merged_situation = await compose_situation_text(target_content_list, summary_model) + merged_style = await compose_style_text(target_style_list, summary_model) + except Exception as e: + print(f" ⚠️ 处理记录 {expr.id} 时 LLM 总结失败: {e}") + # 如果总结失败，使用 fallback + merged_situation = "/".join([c.strip() for c in target_content_list if c.strip()]) or match_expr.situation + merged_style = target_style_list[0] if target_style_list else (match_expr.style or target_style) + else: + # 不使用 LLM 时，使用简单拼接 + merged_situation = "/".join([c.strip() for c in target_content_list if c.strip()]) or match_expr.situation + merged_style = target_style_list[0] if target_style_list else (match_expr.style or target_style) + + merge_info = { + "type": "similar", + "source_id": expr.id, + "target_id": match_expr.id, + "source_style": target_style, + "target_style": match_expr.style, + "source_situation": target_situation, + "target_situation": match_expr.situation, + "similarity": similarity, + "merged_content_list": target_content_list, + "merged_style_list": target_style_list, + "merged_situation": merged_situation, + "merged_style": merged_style, + "llm_used": use_llm and summary_model is not None + } + chat_stat["similar_matches"] += 1 + chat_stat["merges"].append(merge_info) + merge_stats["similar_matches"] += 1 + processed_ids.add(expr.id) + continue + + # 没有匹配，作为新记录 + chat_stat["new_records"] += 1 + merge_stats["new_records"] += 1 + processed_ids.add(expr.id) + + merge_stats["chat_stats"][chat_id] = chat_stat + merge_stats["merge_details"].extend(chat_stat["merges"]) + + return merge_stats + + +def print_merge_results(stats: Dict, show_details: bool = True, max_details: int = 50): + """打印合并结果""" + print("\n" + "=" * 80) + print("Expression 合并模拟结果") + print("=" * 80) + + print("\n📊 总体统计:") + print(f" 总 Expression 数: {stats['total_expressions']}") + print(f" 总聊天数: {stats['total_chats']}") + print(f" 完全匹配合并: {stats['exact_matches']}") + print(f" 相似匹配合并: {stats['similar_matches']}") + print(f" 新记录（无匹配）: {stats['new_records']}") + if stats.get('use_llm'): + print(" LLM 总结: 已启用") + else: + print(" LLM 总结: 未启用（仅模拟）") + + total_merges = stats['exact_matches'] + stats['similar_matches'] + if stats['total_expressions'] > 0: + merge_ratio = (total_merges / stats['total_expressions']) * 100 + print(f" 合并比例: {merge_ratio:.1f}%") + + # 按聊天分组显示 + print("\n📋 按聊天分组统计:") + for chat_id, chat_stat in stats['chat_stats'].items(): + print(f"\n {chat_stat['chat_name']} ({chat_id[:8]}...):") + print(f" 总数: {chat_stat['total']}") + print(f" 完全匹配: {chat_stat['exact_matches']}") + print(f" 相似匹配: {chat_stat['similar_matches']}") + print(f" 新记录: {chat_stat['new_records']}") + + # 显示合并详情 + if show_details and stats['merge_details']: + print(f"\n📝 合并详情 (显示前 {min(max_details, len(stats['merge_details']))} 条):") + print() + + for idx, merge in enumerate(stats['merge_details'][:max_details], 1): + merge_type = "完全匹配" if merge['type'] == 'exact' else f"相似匹配 (相似度: {merge['similarity']:.3f})" + print(f" {idx}. {merge_type}") + print(f" 源记录 ID: {merge['source_id']}") + print(f" 目标记录 ID: {merge['target_id']}") + print(f" 源 Style: {merge['source_style'][:50]}") + print(f" 目标 Style: {merge['target_style'][:50]}") + print(f" 源 Situation: {merge['source_situation'][:50]}") + print(f" 目标 Situation: {merge['target_situation'][:50]}") + + # 显示合并后的结果 + if 'merged_situation' in merge: + print(f" → 合并后 Situation: {merge['merged_situation'][:50]}") + if 'merged_style' in merge: + print(f" → 合并后 Style: {merge['merged_style'][:50]}") + if merge.get('llm_used'): + print(" → LLM 总结: 已使用") + elif merge['type'] == 'similar': + print(" → LLM 总结: 未使用（模拟模式）") + + # 显示合并后的列表 + if 'merged_content_list' in merge and len(merge['merged_content_list']) > 1: + print(f" → Content List ({len(merge['merged_content_list'])} 项): {', '.join(merge['merged_content_list'][:3])}") + if len(merge['merged_content_list']) > 3: + print(f" ... 还有 {len(merge['merged_content_list']) - 3} 项") + if 'merged_style_list' in merge and len(merge['merged_style_list']) > 1: + print(f" → Style List ({len(merge['merged_style_list'])} 项): {', '.join(merge['merged_style_list'][:3])}") + if len(merge['merged_style_list']) > 3: + print(f" ... 还有 {len(merge['merged_style_list']) - 3} 项") + print() + + if len(stats['merge_details']) > max_details: + print(f" ... 还有 {len(stats['merge_details']) - max_details} 条合并记录未显示") + + +def main(): + """主函数""" + parser = argparse.ArgumentParser(description="模拟 Expression 合并过程") + parser.add_argument( + "--chat-id", + type=str, + default=None, + help="指定要分析的 chat_id（不指定则分析所有）" + ) + parser.add_argument( + "--similarity-threshold", + type=float, + default=0.75, + help="相似度阈值 (0-1, 默认: 0.75)" + ) + parser.add_argument( + "--no-details", + action="store_true", + help="不显示详细信息，只显示统计" + ) + parser.add_argument( + "--max-details", + type=int, + default=50, + help="最多显示的合并详情数 (默认: 50)" + ) + parser.add_argument( + "--output", + type=str, + default=None, + help="输出文件路径 (默认: 自动生成带时间戳的文件)" + ) + parser.add_argument( + "--use-llm", + action="store_true", + help="启用 LLM 进行实际总结（默认: 仅模拟，不调用 LLM）" + ) + parser.add_argument( + "--max-samples", + type=int, + default=10, + help="最多随机抽取的 Expression 数量 (默认: 10，设置为 0 表示不限制)" + ) + + args = parser.parse_args() + + # 验证阈值 + if not 0 <= args.similarity_threshold <= 1: + print("错误: similarity-threshold 必须在 0-1 之间") + return + + # 确定输出文件路径 + if args.output: + output_file = args.output + else: + timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") + output_dir = os.path.join(project_root, "data", "temp") + os.makedirs(output_dir, exist_ok=True) + output_file = os.path.join(output_dir, f"expression_merge_simulation_{timestamp}.txt") + + # 查询 Expression 记录 + print("正在从数据库加载Expression数据...") + try: + if args.chat_id: + expressions = list(Expression.select().where(Expression.chat_id == args.chat_id)) + print(f"✅ 成功加载 {len(expressions)} 条Expression记录 (chat_id: {args.chat_id})") + else: + expressions = list(Expression.select()) + print(f"✅ 成功加载 {len(expressions)} 条Expression记录") + except Exception as e: + print(f"❌ 加载数据失败: {e}") + return + + if not expressions: + print("❌ 数据库中没有找到Expression记录") + return + + # 执行合并模拟 + print(f"\n正在模拟合并过程（相似度阈值: {args.similarity_threshold}，最大样本数: {args.max_samples}）...") + if args.use_llm: + print("⚠️ 已启用 LLM 总结，将进行实际的 API 调用") + else: + print("ℹ️ 未启用 LLM 总结，仅进行模拟（使用 --use-llm 启用实际 LLM 调用）") + + stats = asyncio.run( + simulate_merge( + expressions, + similarity_threshold=args.similarity_threshold, + use_llm=args.use_llm, + max_samples=args.max_samples, + ) + ) + + # 输出结果 + original_stdout = sys.stdout + try: + with open(output_file, "w", encoding="utf-8") as f: + sys.stdout = f + print_merge_results(stats, show_details=not args.no_details, max_details=args.max_details) + sys.stdout = original_stdout + + # 同时在控制台输出 + print_merge_results(stats, show_details=not args.no_details, max_details=args.max_details) + + except Exception as e: + sys.stdout = original_stdout + print(f"❌ 写入文件失败: {e}") + return + + print(f"\n✅ 模拟结果已保存到: {output_file}") + + +if __name__ == "__main__": + main() + diff --git a/scripts/expression_similarity_analysis.py b/scripts/expression_similarity_analysis.py new file mode 100644 index 00000000..aa1b149e --- /dev/null +++ b/scripts/expression_similarity_analysis.py @@ -0,0 +1,559 @@ +""" +分析expression库中situation和style的相似度 + +用法: + python scripts/expression_similarity_analysis.py + 或指定阈值: + python scripts/expression_similarity_analysis.py --situation-threshold 0.8 --style-threshold 0.7 +""" + +import sys +import os +import argparse +from typing import List, Tuple +from collections import defaultdict +from difflib import SequenceMatcher +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) + +# Import after setting up path (required for project imports) +from src.common.database.database_model import Expression, ChatStreams # noqa: E402 +from src.config.config import global_config # noqa: E402 +from src.chat.message_receive.chat_stream import get_chat_manager # noqa: E402 + + +class TeeOutput: + """同时输出到控制台和文件的类""" + def __init__(self, file_path: str): + self.file = open(file_path, "w", encoding="utf-8") + self.console = sys.stdout + + def write(self, text: str): + """写入文本到控制台和文件""" + self.console.write(text) + self.file.write(text) + self.file.flush() # 立即刷新到文件 + + def flush(self): + """刷新输出""" + self.console.flush() + self.file.flush() + + def close(self): + """关闭文件""" + if self.file: + self.file.close() + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_val, exc_tb): + self.close() + return False + + +def _parse_stream_config_to_chat_id(stream_config_str: str) -> str | None: + """ + 解析'platform:id:type'为chat_id，直接复用 ChatManager 的逻辑 + """ + 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" + return get_chat_manager().get_stream_id(platform, str(id_str), is_group=is_group) + except Exception: + return None + + +def build_chat_id_groups() -> dict[str, set[str]]: + """ + 根据expression_groups配置，构建chat_id到相关chat_id集合的映射 + + Returns: + dict: {chat_id: set of related chat_ids (including itself)} + """ + groups = global_config.expression.expression_groups + chat_id_groups: dict[str, set[str]] = {} + + # 检查是否存在全局共享组（包含"*"的组） + 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 stream_config_str == "*": + continue + if chat_id_candidate := _parse_stream_config_to_chat_id(stream_config_str): + all_chat_ids.add(chat_id_candidate) + + # 所有chat_id都互相相关 + for chat_id in all_chat_ids: + chat_id_groups[chat_id] = all_chat_ids.copy() + else: + # 处理普通组 + for group in groups: + group_chat_ids = set() + for stream_config_str in group: + if chat_id_candidate := _parse_stream_config_to_chat_id(stream_config_str): + group_chat_ids.add(chat_id_candidate) + + # 组内的所有chat_id都互相相关 + for chat_id in group_chat_ids: + if chat_id not in chat_id_groups: + chat_id_groups[chat_id] = set() + chat_id_groups[chat_id].update(group_chat_ids) + + # 确保每个chat_id至少包含自身 + for chat_id in chat_id_groups: + chat_id_groups[chat_id].add(chat_id) + + return chat_id_groups + + +def are_chat_ids_related(chat_id1: str, chat_id2: str, chat_id_groups: dict[str, set[str]]) -> bool: + """ + 判断两个chat_id是否相关（相同或同组） + + Args: + chat_id1: 第一个chat_id + chat_id2: 第二个chat_id + chat_id_groups: chat_id到相关chat_id集合的映射 + + Returns: + bool: 如果两个chat_id相同或同组，返回True + """ + if chat_id1 == chat_id2: + return True + + # 如果chat_id1在映射中，检查chat_id2是否在其相关集合中 + if chat_id1 in chat_id_groups: + return chat_id2 in chat_id_groups[chat_id1] + + # 如果chat_id1不在映射中，说明它不在任何组中，只与自己相关 + return False + + +def get_chat_name(chat_id: str) -> str: + """根据 chat_id 获取聊天名称""" + try: + chat_stream = ChatStreams.get_or_none(ChatStreams.stream_id == chat_id) + if chat_stream is None: + return f"未知聊天 ({chat_id[:8]}...)" + + if chat_stream.group_name: + return f"{chat_stream.group_name}" + elif chat_stream.user_nickname: + return f"{chat_stream.user_nickname}的私聊" + else: + return f"未知聊天 ({chat_id[:8]}...)" + except Exception: + return f"查询失败 ({chat_id[:8]}...)" + + +def text_similarity(text1: str, text2: str) -> float: + """ + 计算两个文本的相似度 + 使用SequenceMatcher计算相似度，返回0-1之间的值 + 在计算前会移除"使用"和"句式"这两个词 + """ + if not text1 or not text2: + return 0.0 + + # 移除"使用"和"句式"这两个词 + def remove_ignored_words(text: str) -> str: + """移除需要忽略的词""" + text = text.replace("使用", "") + text = text.replace("句式", "") + return text.strip() + + cleaned_text1 = remove_ignored_words(text1) + cleaned_text2 = remove_ignored_words(text2) + + # 如果清理后文本为空，返回0 + if not cleaned_text1 or not cleaned_text2: + return 0.0 + + return SequenceMatcher(None, cleaned_text1, cleaned_text2).ratio() + + +def find_similar_pairs( + expressions: List[Expression], + field_name: str, + threshold: float, + max_pairs: int = None +) -> List[Tuple[int, int, float, str, str]]: + """ + 找出相似的expression对 + + Args: + expressions: Expression对象列表 + field_name: 要比较的字段名 ('situation' 或 'style') + threshold: 相似度阈值 (0-1) + max_pairs: 最多返回的对数，None表示返回所有 + + Returns: + List of (index1, index2, similarity, text1, text2) tuples + """ + similar_pairs = [] + n = len(expressions) + + print(f"正在分析 {field_name} 字段的相似度...") + print(f"总共需要比较 {n * (n - 1) // 2} 对...") + + for i in range(n): + if (i + 1) % 100 == 0: + print(f" 已处理 {i + 1}/{n} 个项目...") + + expr1 = expressions[i] + text1 = getattr(expr1, field_name, "") + + for j in range(i + 1, n): + expr2 = expressions[j] + text2 = getattr(expr2, field_name, "") + + similarity = text_similarity(text1, text2) + + if similarity >= threshold: + similar_pairs.append((i, j, similarity, text1, text2)) + + # 按相似度降序排序 + similar_pairs.sort(key=lambda x: x[2], reverse=True) + + if max_pairs: + similar_pairs = similar_pairs[:max_pairs] + + return similar_pairs + + +def group_similar_items( + expressions: List[Expression], + field_name: str, + threshold: float, + chat_id_groups: dict[str, set[str]] +) -> List[List[int]]: + """ + 将相似的expression分组（仅比较相同chat_id或同组的项目） + + Args: + expressions: Expression对象列表 + field_name: 要比较的字段名 ('situation' 或 'style') + threshold: 相似度阈值 (0-1) + chat_id_groups: chat_id到相关chat_id集合的映射 + + Returns: + List of groups, each group is a list of indices + """ + n = len(expressions) + # 使用并查集的思想来分组 + parent = list(range(n)) + + def find(x): + if parent[x] != x: + parent[x] = find(parent[x]) + return parent[x] + + def union(x, y): + px, py = find(x), find(y) + if px != py: + parent[px] = py + + print(f"正在对 {field_name} 字段进行分组（仅比较相同chat_id或同组的项目）...") + + # 统计需要比较的对数 + total_pairs = 0 + for i in range(n): + for j in range(i + 1, n): + if are_chat_ids_related(expressions[i].chat_id, expressions[j].chat_id, chat_id_groups): + total_pairs += 1 + + print(f"总共需要比较 {total_pairs} 对（已过滤不同chat_id且不同组的项目）...") + + compared_pairs = 0 + for i in range(n): + if (i + 1) % 100 == 0: + print(f" 已处理 {i + 1}/{n} 个项目...") + + expr1 = expressions[i] + text1 = getattr(expr1, field_name, "") + + for j in range(i + 1, n): + expr2 = expressions[j] + + # 只比较相同chat_id或同组的项目 + if not are_chat_ids_related(expr1.chat_id, expr2.chat_id, chat_id_groups): + continue + + compared_pairs += 1 + text2 = getattr(expr2, field_name, "") + + similarity = text_similarity(text1, text2) + + if similarity >= threshold: + union(i, j) + + # 收集分组 + groups = defaultdict(list) + for i in range(n): + root = find(i) + groups[root].append(i) + + # 只返回包含多个项目的组 + result = [group for group in groups.values() if len(group) > 1] + result.sort(key=len, reverse=True) + + return result + + +def print_similarity_analysis( + expressions: List[Expression], + field_name: str, + threshold: float, + chat_id_groups: dict[str, set[str]], + show_details: bool = True, + max_groups: int = 20 +): + """打印相似度分析结果""" + print("\n" + "=" * 80) + print(f"{field_name.upper()} 相似度分析 (阈值: {threshold})") + print("=" * 80) + + # 分组分析 + groups = group_similar_items(expressions, field_name, threshold, chat_id_groups) + + total_items = len(expressions) + similar_items_count = sum(len(group) for group in groups) + unique_groups = len(groups) + + print("\n📊 统计信息:") + print(f" 总项目数: {total_items}") + print(f" 相似项目数: {similar_items_count} ({similar_items_count / total_items * 100:.1f}%)") + print(f" 相似组数: {unique_groups}") + print(f" 平均每组项目数: {similar_items_count / unique_groups:.1f}" if unique_groups > 0 else " 平均每组项目数: 0") + + if not groups: + print(f"\n未找到相似度 >= {threshold} 的项目组") + return + + print(f"\n📋 相似组详情 (显示前 {min(max_groups, len(groups))} 组):") + print() + + for group_idx, group in enumerate(groups[:max_groups], 1): + print(f"组 {group_idx} (共 {len(group)} 个项目):") + + if show_details: + # 显示组内所有项目的详细信息 + for idx in group: + expr = expressions[idx] + text = getattr(expr, field_name, "") + chat_name = get_chat_name(expr.chat_id) + + # 截断过长的文本 + display_text = text[:60] + "..." if len(text) > 60 else text + + print(f" [{expr.id}] {display_text}") + print(f" 聊天: {chat_name}, Count: {expr.count}") + + # 计算组内平均相似度 + if len(group) > 1: + similarities = [] + above_threshold_pairs = [] # 存储满足阈值的相似对 + above_threshold_count = 0 + for i in range(len(group)): + for j in range(i + 1, len(group)): + text1 = getattr(expressions[group[i]], field_name, "") + text2 = getattr(expressions[group[j]], field_name, "") + sim = text_similarity(text1, text2) + similarities.append(sim) + if sim >= threshold: + above_threshold_count += 1 + # 存储满足阈值的对的信息 + expr1 = expressions[group[i]] + expr2 = expressions[group[j]] + display_text1 = text1[:40] + "..." if len(text1) > 40 else text1 + display_text2 = text2[:40] + "..." if len(text2) > 40 else text2 + above_threshold_pairs.append(( + expr1.id, display_text1, + expr2.id, display_text2, + sim + )) + + if similarities: + avg_sim = sum(similarities) / len(similarities) + min_sim = min(similarities) + max_sim = max(similarities) + above_threshold_ratio = above_threshold_count / len(similarities) * 100 + print(f" 平均相似度: {avg_sim:.3f} (范围: {min_sim:.3f} - {max_sim:.3f})") + print(f" 满足阈值({threshold})的比例: {above_threshold_ratio:.1f}% ({above_threshold_count}/{len(similarities)})") + + # 显示满足阈值的相似对（这些是直接连接，导致它们被分到一组） + if above_threshold_pairs: + print(" ⚠️ 直接相似的对 (这些对导致它们被分到一组):") + # 按相似度降序排序 + above_threshold_pairs.sort(key=lambda x: x[4], reverse=True) + for idx1, text1, idx2, text2, sim in above_threshold_pairs[:10]: # 最多显示10对 + print(f" [{idx1}] ↔ [{idx2}]: {sim:.3f}") + print(f" \"{text1}\" ↔ \"{text2}\"") + if len(above_threshold_pairs) > 10: + print(f" ... 还有 {len(above_threshold_pairs) - 10} 对满足阈值") + else: + print(f" ⚠️ 警告: 组内没有任何对满足阈值({threshold:.2f})，可能是通过传递性连接") + else: + # 只显示组内第一个项目作为示例 + expr = expressions[group[0]] + text = getattr(expr, field_name, "") + display_text = text[:60] + "..." if len(text) > 60 else text + print(f" 示例: {display_text}") + print(f" ... 还有 {len(group) - 1} 个相似项目") + + print() + + if len(groups) > max_groups: + print(f"... 还有 {len(groups) - max_groups} 组未显示") + + +def main(): + """主函数""" + parser = argparse.ArgumentParser(description="分析expression库中situation和style的相似度") + parser.add_argument( + "--situation-threshold", + type=float, + default=0.7, + help="situation相似度阈值 (0-1, 默认: 0.7)" + ) + parser.add_argument( + "--style-threshold", + type=float, + default=0.7, + help="style相似度阈值 (0-1, 默认: 0.7)" + ) + parser.add_argument( + "--no-details", + action="store_true", + help="不显示详细信息，只显示统计" + ) + parser.add_argument( + "--max-groups", + type=int, + default=20, + help="最多显示的组数 (默认: 20)" + ) + parser.add_argument( + "--output", + type=str, + default=None, + help="输出文件路径 (默认: 自动生成带时间戳的文件)" + ) + + args = parser.parse_args() + + # 验证阈值 + if not 0 <= args.situation_threshold <= 1: + print("错误: situation-threshold 必须在 0-1 之间") + return + if not 0 <= args.style_threshold <= 1: + print("错误: style-threshold 必须在 0-1 之间") + return + + # 确定输出文件路径 + if args.output: + output_file = args.output + else: + # 自动生成带时间戳的输出文件 + timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") + output_dir = os.path.join(project_root, "data", "temp") + os.makedirs(output_dir, exist_ok=True) + output_file = os.path.join(output_dir, f"expression_similarity_analysis_{timestamp}.txt") + + # 使用TeeOutput同时输出到控制台和文件 + with TeeOutput(output_file) as tee: + # 临时替换sys.stdout + original_stdout = sys.stdout + sys.stdout = tee + + try: + print("=" * 80) + print("Expression 相似度分析工具") + print("=" * 80) + print(f"输出文件: {output_file}") + print() + + _run_analysis(args) + + finally: + # 恢复原始stdout + sys.stdout = original_stdout + + print(f"\n✅ 分析结果已保存到: {output_file}") + + +def _run_analysis(args): + """执行分析的主逻辑""" + + # 查询所有Expression记录 + print("正在从数据库加载Expression数据...") + try: + expressions = list(Expression.select()) + except Exception as e: + print(f"❌ 加载数据失败: {e}") + return + + if not expressions: + print("❌ 数据库中没有找到Expression记录") + return + + print(f"✅ 成功加载 {len(expressions)} 条Expression记录") + print() + + # 构建chat_id分组映射 + print("正在构建chat_id分组映射（根据expression_groups配置）...") + try: + chat_id_groups = build_chat_id_groups() + print(f"✅ 成功构建 {len(chat_id_groups)} 个chat_id的分组映射") + if chat_id_groups: + # 统计分组信息 + total_related = sum(len(related) for related in chat_id_groups.values()) + avg_related = total_related / len(chat_id_groups) + print(f" 平均每个chat_id与 {avg_related:.1f} 个chat_id相关（包括自身）") + print() + except Exception as e: + print(f"⚠️ 构建chat_id分组映射失败: {e}") + print(" 将使用默认行为：只比较相同chat_id的项目") + chat_id_groups = {} + + # 分析situation相似度 + print_similarity_analysis( + expressions, + "situation", + args.situation_threshold, + chat_id_groups, + show_details=not args.no_details, + max_groups=args.max_groups + ) + + # 分析style相似度 + print_similarity_analysis( + expressions, + "style", + args.style_threshold, + chat_id_groups, + show_details=not args.no_details, + max_groups=args.max_groups + ) + + print("\n" + "=" * 80) + print("分析完成！") + print("=" * 80) + + +if __name__ == "__main__": + main() + diff --git a/scripts/import_openie.py b/scripts/import_openie.py index f9405f59..4057a52c 100644 --- a/scripts/import_openie.py +++ b/scripts/import_openie.py @@ -4,10 +4,12 @@ # print("未找到quick_algo库，无法使用quick_algo算法") # print("请安装quick_algo库 - 在lib.quick_algo中，执行命令：python setup.py build_ext --inplace") +import argparse import sys import os import asyncio from time import sleep +from typing import Optional sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))) from src.chat.knowledge.embedding_store import EmbeddingManager @@ -71,7 +73,12 @@ def hash_deduplicate( return new_raw_paragraphs, new_triple_list_data -def handle_import_openie(openie_data: OpenIE, embed_manager: EmbeddingManager, kg_manager: KGManager) -> bool: +def handle_import_openie( + openie_data: OpenIE, + embed_manager: EmbeddingManager, + kg_manager: KGManager, + non_interactive: bool = False, +) -> bool: # sourcery skip: extract-method # 从OpenIE数据中提取段落原文与三元组列表 # 索引的段落原文 @@ -124,8 +131,13 @@ def handle_import_openie(openie_data: OpenIE, embed_manager: EmbeddingManager, k logger.info("所有数据均完整，没有发现缺失字段。") return False # 新增：提示用户是否删除非法文段继续导入 - # 将print移到所有logger.error之后，确保不会被冲掉 + # 在非交互模式下，不再询问用户，而是直接报错终止 logger.info(f"\n检测到非法文段，共{len(missing_idxs)}条。") + if non_interactive: + logger.error( + "检测到非法文段且当前处于非交互模式，无法询问是否删除非法文段，导入终止。" + ) + sys.exit(1) logger.info("\n是否删除所有非法文段后继续导入？(y/n): ", end="") user_choice = input().strip().lower() if user_choice != "y": @@ -174,20 +186,25 @@ def handle_import_openie(openie_data: OpenIE, embed_manager: EmbeddingManager, k return True -async def main_async(): # sourcery skip: dict-comprehension +async def main_async(non_interactive: bool = False) -> bool: # sourcery skip: dict-comprehension # 新增确认提示 - print("=== 重要操作确认 ===") - print("OpenIE导入时会大量发送请求，可能会撞到请求速度上限，请注意选用的模型") - print("同之前样例：在本地模型下，在70分钟内我们发送了约8万条请求，在网络允许下，速度会更快") - print("推荐使用硅基流动的Pro/BAAI/bge-m3") - print("每百万Token费用为0.7元") - print("知识导入时，会消耗大量系统资源，建议在较好配置电脑上运行") - print("同上样例，导入时10700K几乎跑满，14900HX占用80%，峰值内存占用约3G") - confirm = input("确认继续执行？(y/n): ").strip().lower() - if confirm != "y": - logger.info("用户取消操作") - print("操作已取消") - sys.exit(1) + if non_interactive: + logger.warning( + "当前处于非交互模式，将跳过导入开销确认提示，直接开始执行 OpenIE 导入。" + ) + else: + print("=== 重要操作确认 ===") + print("OpenIE导入时会大量发送请求，可能会撞到请求速度上限，请注意选用的模型") + print("同之前样例：在本地模型下，在70分钟内我们发送了约8万条请求，在网络允许下，速度会更快") + print("推荐使用硅基流动的Pro/BAAI/bge-m3") + print("每百万Token费用为0.7元") + print("知识导入时，会消耗大量系统资源，建议在较好配置电脑上运行") + print("同上样例，导入时10700K几乎跑满，14900HX占用80%，峰值内存占用约3G") + confirm = input("确认继续执行？(y/n): ").strip().lower() + if confirm != "y": + logger.info("用户取消操作") + print("操作已取消") + sys.exit(1) print("\n" + "=" * 40 + "\n") ensure_openie_dir() # 确保OpenIE目录存在 logger.info("----开始导入openie数据----\n") @@ -235,14 +252,27 @@ async def main_async(): # sourcery skip: dict-comprehension except Exception as e: logger.error(f"导入OpenIE数据文件时发生错误：{e}") return False - if handle_import_openie(openie_data, embed_manager, kg_manager) is False: + if handle_import_openie(openie_data, embed_manager, kg_manager, non_interactive=non_interactive) is False: logger.error("处理OpenIE数据时发生错误") return False - return None + return True -def main(): - """主函数 - 设置新的事件循环并运行异步主函数""" +def main(argv: Optional[list[str]] = None) -> None: + """主函数 - 解析参数并运行异步主流程。""" + parser = argparse.ArgumentParser( + description=( + "OpenIE 导入脚本：读取 data/openie 中的 OpenIE JSON 批次，" + "将其导入到 LPMM 的向量库与知识图中。" + ) + ) + parser.add_argument( + "--non-interactive", + action="store_true", + help="非交互模式：跳过导入确认提示以及非法文段删除询问，遇到非法文段时直接报错退出。", + ) + args = parser.parse_args(argv) + # 检查是否有现有的事件循环 try: loop = asyncio.get_running_loop() @@ -255,13 +285,22 @@ def main(): loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) + ok: bool = False try: # 在新的事件循环中运行异步主函数 - loop.run_until_complete(main_async()) + ok = loop.run_until_complete(main_async(non_interactive=args.non_interactive)) + print( + "\n[NOTICE] OpenIE 导入脚本执行完毕。如主程序（聊天 / WebUI）已在运行，" + "请重启主程序，或在主程序内部调用一次 lpmm_start_up() 以应用最新 LPMM 知识库。" + ) + print("[NOTICE] 如果不清楚 lpmm_start_up 是什么，直接重启主程序即可。") finally: # 确保事件循环被正确关闭 if not loop.is_closed(): loop.close() + if not ok: + # 统一错误码，方便在非交互场景下检测失败 + sys.exit(1) if __name__ == "__main__": diff --git a/scripts/info_extraction.py b/scripts/info_extraction.py index 9ef8c098..b5068b0f 100644 --- a/scripts/info_extraction.py +++ b/scripts/info_extraction.py @@ -1,3 +1,4 @@ +import argparse import json import os import signal @@ -5,6 +6,7 @@ from concurrent.futures import ThreadPoolExecutor, as_completed from threading import Lock, Event import sys import datetime +from typing import Optional sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))) # 添加项目根目录到 sys.path @@ -115,22 +117,34 @@ def signal_handler(_signum, _frame): sys.exit(0) -def main(): # sourcery skip: comprehension-to-generator, extract-method +def _run(non_interactive: bool = False) -> None: # sourcery skip: comprehension-to-generator, extract-method # 设置信号处理器 signal.signal(signal.SIGINT, signal_handler) ensure_dirs() # 确保目录存在 # 新增用户确认提示 - print("=== 重要操作确认，请认真阅读以下内容哦 ===") - print("实体提取操作将会花费较多api余额和时间，建议在空闲时段执行。") - print("举例：600万字全剧情，提取选用deepseek v3 0324，消耗约40元，约3小时。") - print("建议使用硅基流动的非Pro模型") - print("或者使用可以用赠金抵扣的Pro模型") - print("请确保账户余额充足，并且在执行前确认无误。") - confirm = input("确认继续执行？(y/n): ").strip().lower() - if confirm != "y": - logger.info("用户取消操作") - print("操作已取消") - sys.exit(1) + if non_interactive: + logger.warning( + "当前处于非交互模式，将跳过费用与时长确认提示，直接开始进行实体提取操作。" + ) + else: + print("=== 重要操作确认，请认真阅读以下内容哦 ===") + print("实体提取操作将会花费较多api余额和时间，建议在空闲时段执行。") + print("举例：600万字全剧情，提取选用deepseek v3 0324，消耗约40元，约3小时。") + print("建议使用硅基流动的非Pro模型") + print("或者使用可以用赠金抵扣的Pro模型") + print("请确保账户余额充足，并且在执行前确认无误。") + confirm = input("确认继续执行？(y/n): ").strip().lower() + if confirm != "y": + logger.info("用户取消操作") + print("操作已取消") + sys.exit(1) + + # 友好提示：说明“网络错误(可重试)”日志属于正常自动重试行为，避免用户误以为任务失败 + print( + "\n提示：在提取过程中，如果看到模型出现“网络错误(可重试)”等日志，" + "表示系统正在自动重试请求，一般不会影响整体导入结果，请耐心等待即可。\n" + ) + print("\n" + "=" * 40 + "\n") ensure_dirs() # 确保目录存在 logger.info("--------进行信息提取--------\n") @@ -215,5 +229,22 @@ def main(): # sourcery skip: comprehension-to-generator, extract-method logger.info(f"提取失败的文段SHA256：{failed_sha256}") +def main(argv: Optional[list[str]] = None) -> None: + parser = argparse.ArgumentParser( + description=( + "LPMM 信息提取脚本：从 data/lpmm_raw_data/*.txt 中读取原始段落，" + "调用 LLM 提取实体和三元组，并生成 OpenIE JSON 批次文件。" + ) + ) + parser.add_argument( + "--non-interactive", + action="store_true", + help="非交互模式：跳过费用确认提示，直接开始执行；适用于 CI / 定时任务等场景。", + ) + args = parser.parse_args(argv) + + _run(non_interactive=args.non_interactive) + + if __name__ == "__main__": main() diff --git a/scripts/inspect_lpmm_batch.py b/scripts/inspect_lpmm_batch.py new file mode 100644 index 00000000..2ed719cf --- /dev/null +++ b/scripts/inspect_lpmm_batch.py @@ -0,0 +1,132 @@ +import argparse +import json +import os +import sys +from pathlib import Path +from typing import List, Tuple + +# 确保能导入 src.* +sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))) + +from src.chat.knowledge.utils.hash import get_sha256 +from src.chat.knowledge.embedding_store import EmbeddingManager +from src.chat.knowledge.kg_manager import KGManager +from src.common.logger import get_logger + +logger = get_logger("inspect_lpmm_batch") + + +def load_openie_hashes(path: Path) -> Tuple[List[str], List[str], List[str]]: + """从 OpenIE JSON 中提取段落 / 实体 / 关系的哈希 + + 注意：实体既包括 extracted_entities 中的条目，也包括三元组中的主语/宾语， + 以与 KG 构图逻辑保持一致。 + """ + with path.open("r", encoding="utf-8") as f: + data = json.load(f) + + pg_hashes: List[str] = [] + ent_hashes: List[str] = [] + rel_hashes: List[str] = [] + + for doc in data.get("docs", []): + if not isinstance(doc, dict): + continue + idx = doc.get("idx") + if isinstance(idx, str) and idx.strip(): + pg_hashes.append(idx.strip()) + + ents = doc.get("extracted_entities", []) + if isinstance(ents, list): + for e in ents: + if isinstance(e, str): + ent_hashes.append(get_sha256(e)) + + triples = doc.get("extracted_triples", []) + if isinstance(triples, list): + for t in triples: + if isinstance(t, list) and len(t) == 3: + # 主语/宾语作为实体参与构图 + subj, _, obj = t + if isinstance(subj, str): + ent_hashes.append(get_sha256(subj)) + if isinstance(obj, str): + ent_hashes.append(get_sha256(obj)) + rel_hashes.append(get_sha256(str(tuple(t)))) + + # 去重但保留顺序 + def unique(seq: List[str]) -> List[str]: + seen = set() + return [x for x in seq if not (x in seen or seen.add(x))] + + return unique(pg_hashes), unique(ent_hashes), unique(rel_hashes) + + +def main() -> None: + parser = argparse.ArgumentParser( + description="检查指定 OpenIE 文件对应批次在当前向量库与 KG 中的存在情况（用于验证删除效果）。" + ) + parser.add_argument("--openie-file", required=True, help="OpenIE 输出 JSON 文件路径") + args = parser.parse_args() + + openie_path = Path(args.openie_file) + if not openie_path.exists(): + logger.error(f"OpenIE 文件不存在: {openie_path}") + sys.exit(1) + + pg_hashes, ent_hashes, rel_hashes = load_openie_hashes(openie_path) + logger.info( + f"从 {openie_path.name} 解析到 段落 {len(pg_hashes)} 条，实体 {len(ent_hashes)} 个，关系 {len(rel_hashes)} 条" + ) + + # 加载当前嵌入与 KG + em = EmbeddingManager() + kg = KGManager() + try: + em.load_from_file() + kg.load_from_file() + except Exception as e: + logger.error(f"加载当前知识库失败: {e}") + sys.exit(1) + + graph_nodes = set(kg.graph.get_node_list()) + + # 检查段落 + pg_keys = [f"paragraph-{h}" for h in pg_hashes] + pg_in_vec = sum(1 for k in pg_keys if k in em.paragraphs_embedding_store.store) + pg_in_kg = sum(1 for k in pg_keys if k in graph_nodes) + + # 检查实体 + ent_keys = [f"entity-{h}" for h in ent_hashes] + ent_in_vec = sum(1 for k in ent_keys if k in em.entities_embedding_store.store) + ent_in_kg = sum(1 for k in ent_keys if k in graph_nodes) + + # 检查关系（只针对向量库） + rel_keys = [f"relation-{h}" for h in rel_hashes] + rel_in_vec = sum(1 for k in rel_keys if k in em.relation_embedding_store.store) + + print("==== 批次存在情况（删除前/后对比用） ====") + print(f"段落: 总计 {len(pg_keys)}, 向量库剩余 {pg_in_vec}, KG 中剩余 {pg_in_kg}") + print(f"实体: 总计 {len(ent_keys)}, 向量库剩余 {ent_in_vec}, KG 中剩余 {ent_in_kg}") + print(f"关系: 总计 {len(rel_keys)}, 向量库剩余 {rel_in_vec}") + + # 打印少量仍存在的样例，便于检查内容是否正常 + sample_pg = [k for k in pg_keys if k in graph_nodes][:3] + if sample_pg: + print("\n仍在 KG 中的段落节点示例：") + for k in sample_pg: + nd = kg.graph[k] + content = nd["content"] if "content" in nd else k + print(f"- {k}: {content[:80]}") + + sample_ent = [k for k in ent_keys if k in graph_nodes][:3] + if sample_ent: + print("\n仍在 KG 中的实体节点示例：") + for k in sample_ent: + nd = kg.graph[k] + content = nd["content"] if "content" in nd else k + print(f"- {k}: {content[:80]}") + + +if __name__ == "__main__": + main() diff --git a/scripts/inspect_lpmm_global.py b/scripts/inspect_lpmm_global.py new file mode 100644 index 00000000..13b80e14 --- /dev/null +++ b/scripts/inspect_lpmm_global.py @@ -0,0 +1,71 @@ +import os +import sys +from typing import Set + +# 保证可以导入 src.* +sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))) + +from src.chat.knowledge.embedding_store import EmbeddingManager +from src.chat.knowledge.kg_manager import KGManager +from src.common.logger import get_logger + +logger = get_logger("inspect_lpmm_global") + + +def main() -> None: + """检查当前整库（所有批次）的向量与 KG 状态，用于观察删除对剩余数据的影响。""" + em = EmbeddingManager() + kg = KGManager() + + try: + em.load_from_file() + kg.load_from_file() + except Exception as e: + logger.error(f"加载当前知识库失败: {e}") + sys.exit(1) + + # 向量库统计 + para_cnt = len(em.paragraphs_embedding_store.store) + ent_cnt_vec = len(em.entities_embedding_store.store) + rel_cnt_vec = len(em.relation_embedding_store.store) + + # KG 统计 + nodes = kg.graph.get_node_list() + edges = kg.graph.get_edge_list() + node_set: Set[str] = set(nodes) + + para_nodes = [n for n in nodes if n.startswith("paragraph-")] + ent_nodes = [n for n in nodes if n.startswith("entity-")] + + print("==== 向量库统计 ====") + print(f"段落向量条数: {para_cnt}") + print(f"实体向量条数: {ent_cnt_vec}") + print(f"关系向量条数: {rel_cnt_vec}") + + print("\n==== KG 图统计 ====") + print(f"节点总数: {len(nodes)}") + print(f"边总数: {len(edges)}") + print(f"段落节点数: {len(para_nodes)}") + print(f"实体节点数: {len(ent_nodes)}") + + # ent_appear_cnt 状态 + ent_cnt_meta = len(kg.ent_appear_cnt) + print(f"\n实体计数表条目数: {ent_cnt_meta}") + + # 抽样查看剩余段落/实体内容 + print("\n==== 剩余段落示例（最多 3 条） ====") + for nid in para_nodes[:3]: + nd = kg.graph[nid] + content = nd["content"] if "content" in nd else nid + print(f"- {nid}: {content[:80]}") + + print("\n==== 剩余实体示例（最多 5 条） ====") + for nid in ent_nodes[:5]: + nd = kg.graph[nid] + content = nd["content"] if "content" in nd else nid + print(f"- {nid}: {content[:80]}") + + +if __name__ == "__main__": + main() + diff --git a/scripts/lpmm_manager.py b/scripts/lpmm_manager.py new file mode 100644 index 00000000..9ca42254 --- /dev/null +++ b/scripts/lpmm_manager.py @@ -0,0 +1,541 @@ +import argparse +import os +import re +import sys +from datetime import datetime +from pathlib import Path +from typing import Optional, List + +# 尽量统一控制台编码为 utf-8，避免中文输出报错 +try: + if hasattr(sys.stdout, "reconfigure"): + sys.stdout.reconfigure(encoding="utf-8") + if hasattr(sys.stderr, "reconfigure"): + sys.stderr.reconfigure(encoding="utf-8") +except Exception: + pass + +# 确保能导入 src.* 以及同目录脚本 +CURRENT_DIR = os.path.dirname(__file__) +PROJECT_ROOT = os.path.abspath(os.path.join(CURRENT_DIR, "..")) +if PROJECT_ROOT not in sys.path: + sys.path.append(PROJECT_ROOT) + +from src.common.logger import get_logger # type: ignore +from src.config.config import global_config, model_config # type: ignore + +# 引入各功能脚本的入口函数 +from import_openie import main as import_openie_main # type: ignore +from info_extraction import main as info_extraction_main # type: ignore +from delete_lpmm_items import main as delete_lpmm_items_main # type: ignore +from inspect_lpmm_batch import main as inspect_lpmm_batch_main # type: ignore +from inspect_lpmm_global import main as inspect_lpmm_global_main # type: ignore +from refresh_lpmm_knowledge import main as refresh_lpmm_knowledge_main # type: ignore +from test_lpmm_retrieval import main as test_lpmm_retrieval_main # type: ignore +from raw_data_preprocessor import load_raw_data # type: ignore + + +logger = get_logger("lpmm_manager") + + +ACTION_INFO = { + "prepare_raw": "预处理 data/lpmm_raw_data/*.txt，按空行切分为段落并做去重统计", + "info_extract": "原始 txt -> OpenIE 信息抽取（调用 info_extraction.py）", + "import_openie": "导入 OpenIE 批次到向量库与知识图（调用 import_openie.py）", + "delete": "删除/回滚知识（调用 delete_lpmm_items.py）", + "batch_inspect": "检查指定 OpenIE 批次在当前库中的存在情况（调用 inspect_lpmm_batch.py）", + "global_inspect": "查看当前整库向量与 KG 状态（调用 inspect_lpmm_global.py）", + "refresh": "刷新 LPMM 磁盘数据到内存（调用 refresh_lpmm_knowledge.py）", + "test": "运行 LPMM 检索效果回归测试（调用 test_lpmm_retrieval.py）", + "embedding_helper": "嵌入模型迁移辅助：查看当前嵌入模型/维度并归档 embedding_model_test.json", + "full_import": "一键执行：信息抽取 -> 导入 OpenIE -> 刷新", +} + + +def _with_overridden_argv(extra_args: List[str], target_main) -> None: + """在不修改子脚本的前提下，临时覆盖 sys.argv 以透传参数。""" + old_argv = list(sys.argv) + try: + # 第 0 个元素为“程序名”，后续元素为实际参数 + # 这里不再插入类似 delete_lpmm_items.py 的占位，避免被 argparse 误识别为位置参数 + sys.argv = [old_argv[0]] + extra_args + target_main() + finally: + sys.argv = old_argv + + +def _check_before_info_extract(non_interactive: bool = False) -> bool: + """信息抽取前的轻量级检查。""" + raw_dir = Path(PROJECT_ROOT) / "data" / "lpmm_raw_data" + txt_files = list(raw_dir.glob("*.txt")) + if not txt_files: + msg = ( + f"[WARN] 未在 {raw_dir} 下找到任何 .txt 原始语料文件，" + "info_extraction 可能立即退出或无数据可处理。" + ) + print(msg) + if non_interactive: + logger.error( + "非交互模式下要求原始语料目录中已存在可用的 .txt 文件，请先准备好数据再重试。" + ) + return False + cont = input("仍然继续执行信息提取吗？(y/n): ").strip().lower() + return cont == "y" + return True + + +def _check_before_import_openie(non_interactive: bool = False) -> bool: + """导入 OpenIE 前的轻量级检查。""" + openie_dir = Path(PROJECT_ROOT) / "data" / "openie" + json_files = list(openie_dir.glob("*.json")) + if not json_files: + msg = ( + f"[WARN] 未在 {openie_dir} 下找到任何 OpenIE JSON 文件，" + "import_openie 可能会因为找不到批次而失败。" + ) + print(msg) + if non_interactive: + logger.error( + "非交互模式下要求 data/openie 目录中已存在可用的 OpenIE JSON 文件，请先执行信息提取脚本。" + ) + return False + cont = input("仍然继续执行导入吗？(y/n): ").strip().lower() + return cont == "y" + return True + + +def _warn_if_lpmm_disabled() -> None: + """在部分操作前提醒 lpmm_knowledge.enable 状态。""" + try: + if not getattr(global_config.lpmm_knowledge, "enable", False): + print( + "[WARN] 当前配置 lpmm_knowledge.enable = false，" + "刷新或检索测试可能无法在聊天侧真正启用 LPMM。" + ) + except Exception: + # 配置异常时不阻断主流程，仅忽略提示 + pass + + +def run_action(action: str, extra_args: Optional[List[str]] = None) -> None: + """根据动作名称调度到对应脚本。 + + 这里不重复解析子参数，而是直接调用各脚本的 main()， + 让子脚本保留原有的交互/参数行为。 + """ + logger.info("开始执行操作: %s", action) + + extra_args = extra_args or [] + + try: + if action == "prepare_raw": + logger.info("开始预处理原始语料 (data/lpmm_raw_data/*.txt)...") + sha_list, raw_data = load_raw_data() + print( + f"\n[PREPARE_RAW] 完成原始语料预处理：共 {len(raw_data)} 条段落，" + f"去重后哈希数 {len(sha_list)}。" + ) + elif action == "info_extract": + if not _check_before_info_extract("--non-interactive" in extra_args): + print("已根据用户选择，取消执行信息提取。") + return + _with_overridden_argv(extra_args, info_extraction_main) + elif action == "import_openie": + if not _check_before_import_openie("--non-interactive" in extra_args): + print("已根据用户选择，取消执行导入。") + return + _with_overridden_argv(extra_args, import_openie_main) + elif action == "delete": + _with_overridden_argv(extra_args, delete_lpmm_items_main) + elif action == "batch_inspect": + _with_overridden_argv(extra_args, inspect_lpmm_batch_main) + elif action == "global_inspect": + _with_overridden_argv(extra_args, inspect_lpmm_global_main) + elif action == "refresh": + _warn_if_lpmm_disabled() + _with_overridden_argv(extra_args, refresh_lpmm_knowledge_main) + elif action == "test": + _warn_if_lpmm_disabled() + _with_overridden_argv(extra_args, test_lpmm_retrieval_main) + elif action == "embedding_helper": + # 嵌入模型迁移辅助：查看当前嵌入模型/维度并归档 embedding_model_test.json + _run_embedding_helper() + elif action == "full_import": + # 一键流水线：预处理原始语料 -> 信息抽取 -> 导入 -> 刷新 + logger.info("开始 full_import：预处理原始语料 -> 信息抽取 -> 导入 -> 刷新") + sha_list, raw_data = load_raw_data() + print( + f"\n[FULL_IMPORT] 原始语料预处理完成：共 {len(raw_data)} 条段落，" + f"去重后哈希数 {len(sha_list)}。" + ) + non_interactive = "--non-interactive" in extra_args + if not _check_before_info_extract(non_interactive): + print("已根据用户选择，取消 full_import（信息提取阶段被取消）。") + return + # 使用与单步 info_extract 相同的参数透传机制，确保 --non-interactive 等生效 + _with_overridden_argv(extra_args, info_extraction_main) + if not _check_before_import_openie(non_interactive): + print("已根据用户选择，取消 full_import（导入阶段被取消）。") + return + _with_overridden_argv(extra_args, import_openie_main) + _warn_if_lpmm_disabled() + _with_overridden_argv(extra_args, refresh_lpmm_knowledge_main) + else: + logger.error("未知操作: %s", action) + except KeyboardInterrupt: + logger.info("用户中断当前操作（Ctrl+C）") + except SystemExit: + # 子脚本里大量使用 sys.exit，直接透传即可 + raise + except Exception as exc: # pragma: no cover - 防御性兜底 + logger.error("执行操作 %s 时发生未捕获异常: %s", action, exc) + raise + + +def print_menu() -> None: + print("\n===== LPMM 管理菜单 =====") + for idx, key in enumerate( + [ + "prepare_raw", + "info_extract", + "import_openie", + "delete", + "batch_inspect", + "global_inspect", + "refresh", + "test", + "embedding_helper", + "full_import", + ], + start=1, + ): + desc = ACTION_INFO.get(key, "") + print(f"{idx}. {key:14s} - {desc}") + print("0. 退出") + print("=========================") + + +def interactive_loop() -> None: + """交互式选择模式。""" + key_order = [ + "prepare_raw", + "info_extract", + "import_openie", + "delete", + "batch_inspect", + "global_inspect", + "refresh", + "test", + "embedding_helper", + "full_import", + ] + + while True: + print_menu() + choice = input("请输入选项编号（0-10）：").strip() + + if choice in ("0", "q", "Q", "quit", "exit"): + print("已退出 LPMM 管理器。") + return + + try: + idx = int(choice) + except ValueError: + print("输入无效，请输入 0-10 之间的数字。") + continue + + if not (1 <= idx <= len(key_order)): + print("输入编号超出范围，请重新输入。") + continue + + action = key_order[idx - 1] + print(f"\n你选择了: {action} - {ACTION_INFO.get(action, '')}") + confirm = input("确认执行该操作？(y/n): ").strip().lower() + if confirm != "y": + print("已取消当前操作。\n") + continue + + # 通过交互式问题，尽量帮用户补全对应脚本的常用参数 + extra_args: List[str] = [] + if action == "delete": + extra_args = _interactive_build_delete_args() + elif action == "batch_inspect": + extra_args = _interactive_build_batch_inspect_args() + elif action == "test": + extra_args = _interactive_build_test_args() + else: + extra_args = [] + + run_action(action, extra_args=extra_args) + print("\n当前操作已结束，回到主菜单。\n") + + +def _interactive_choose_openie_file(prompt: str) -> Optional[str]: + """在 data/openie 下列出可选 JSON 文件，并返回用户选择的路径。""" + openie_dir = Path(PROJECT_ROOT) / "data" / "openie" + files = sorted(openie_dir.glob("*.json")) + if not files: + print(f"[WARN] 在 {openie_dir} 下没有找到任何 OpenIE JSON 文件。") + return input(prompt).strip() or None + + print("\n可选的 OpenIE 批次文件：") + for i, f in enumerate(files, start=1): + print(f"{i}. {f.name}") + print("0. 手动输入完整路径") + + while True: + choice = input("请选择文件编号：").strip() + if choice == "0": + manual = input(prompt).strip() + return manual or None + try: + idx = int(choice) + except ValueError: + print("请输入合法的编号。") + continue + if 1 <= idx <= len(files): + return str(files[idx - 1]) + print("编号超出范围，请重试。") + + +def _interactive_build_delete_args() -> List[str]: + """为 delete_lpmm_items 构造常见参数，减少二次交互。""" + print( + "\n[DELETE] 请选择删除方式：\n" + "1. 按哈希文件删除 (--hash-file)\n" + "2. 按 OpenIE 批次删除 (--openie-file)\n" + "3. 按原始语料文件 + 段落索引删除 (--raw-file + --raw-index)\n" + "4. 按关键字搜索现有段落 (--search-text)\n" + "回车跳过，由子脚本自行交互。" + ) + mode = input("输入选项编号（1-4，或回车跳过）：").strip() + args: List[str] = [] + + if mode == "1": + path = input("请输入哈希文件路径（每行一个 hash）：").strip() + if path: + args += ["--hash-file", path] + elif mode == "2": + path = _interactive_choose_openie_file("请输入 OpenIE JSON 文件路径：") + if path: + args += ["--openie-file", path] + elif mode == "3": + raw_file = input("请输入原始语料 txt 文件路径：").strip() + raw_index = input("请输入要删除的段落索引（如 1,3）：").strip() + if raw_file and raw_index: + args += ["--raw-file", raw_file, "--raw-index", raw_index] + elif mode == "4": + text = input("请输入用于搜索的关键字（出现在段落原文中）：").strip() + if text: + args += ["--search-text", text] + else: + # 留空则完全交给子脚本交互 + return [] + + # 进一步询问与安全相关的布尔选项 + print( + "\n[DELETE] 接下来是一些安全相关选项的说明：\n" + "- 删除实体向量/节点：会一并清理与这些段落关联的实体节点及其向量；\n" + "- 删除关系向量：在上面的基础上，额外清理关系向量（一般与删除实体一同使用）；\n" + "- 删除孤立实体节点：删除后若实体不再连接任何段落，将其从图中移除，避免残留孤点；\n" + "- dry-run：只预览将要删除的内容，不真正修改任何数据；\n" + "- 跳过交互确认(--yes)：直接执行删除操作，适合脚本化或已充分确认的场景；\n" + "- 单次最大删除节点数上限：防止一次性删除规模过大，起到误操作保护作用；\n" + "- 一般情况下建议同时删除实体向量/节点/关系向量/节点，以确保知识图谱的完整性。" + ) + + # 快速选项：按推荐方式清理所有相关实体/关系 + quick_all = input( + "是否使用推荐策略：同时删除关联的实体向量/节点、关系向量，并清理孤立实体？(Y/n): " + ).strip().lower() + if quick_all in ("", "y", "yes"): + args.extend(["--delete-entities", "--delete-relations", "--remove-orphan-entities"]) + else: + # 仅当未使用快速方案时，再逐项询问 + if input("是否同时删除实体向量/节点？(y/N): ").strip().lower() == "y": + args.append("--delete-entities") + if input("是否同时删除关系向量？(y/N): ").strip().lower() == "y": + args.append("--delete-relations") + + if input("是否删除孤立实体节点？(y/N): ").strip().lower() == "y": + args.append("--remove-orphan-entities") + + if input("是否以 dry-run 预览而不真正删除？(y/N): ").strip().lower() == "y": + args.append("--dry-run") + else: + if input("是否跳过交互确认直接删除？(默认否，请谨慎) (y/N): ").strip().lower() == "y": + args.append("--yes") + + max_nodes = input("单次最大删除节点数上限（回车使用默认 2000）：").strip() + if max_nodes: + args += ["--max-delete-nodes", max_nodes] + + return args + + +def _interactive_build_batch_inspect_args() -> List[str]: + """为 inspect_lpmm_batch 构造 --openie-file 参数。""" + path = _interactive_choose_openie_file( + "请输入要检查的 OpenIE JSON 文件路径（回车跳过，由子脚本自行交互）：" + ) + if not path: + return [] + return ["--openie-file", path] + + +def _interactive_build_test_args() -> List[str]: + """为 test_lpmm_retrieval 构造自定义测试用例参数。""" + print( + "\n[TEST] 你可以：\n" + "- 直接回车使用内置的默认测试用例；\n" + "- 或者输入一条自定义问题，并指定期望命中的关键字。" + ) + query = input("请输入自定义测试问题（回车则使用默认用例）：").strip() + if not query: + return [] + + expect = input("请输入期望命中的关键字（可选，多项用逗号分隔）：").strip() + args: List[str] = ["--query", query] + if expect: + for kw in expect.split(","): + kw = kw.strip() + if kw: + args.extend(["--expect-keyword", kw]) + return args + + +def _run_embedding_helper() -> None: + """嵌入模型迁移辅助：展示当前配置，并安全归档 embedding_model_test.json。""" + from src.chat.knowledge.embedding_store import EMBEDDING_TEST_FILE # type: ignore + + # 1. 读取当前配置中的嵌入维度与模型信息 + current_dim = getattr(getattr(global_config, "lpmm_knowledge", None), "embedding_dimension", None) + embed_task = getattr(model_config.model_task_config, "embedding", None) + model_ids: List[str] = [] + if embed_task is not None: + model_ids = getattr(embed_task, "model_list", []) or [] + primary_model = model_ids[0] if model_ids else "unknown" + safe_model_name = re.sub(r"[^0-9A-Za-z_.-]+", "_", primary_model) or "unknown" + + print("\n===== 嵌入模型迁移辅助 (embedding_helper) =====") + print(f"- 当前嵌入模型标识（model_task_config.embedding.model_list[0]）: {primary_model}") + print(f"- 当前配置中的嵌入维度 (lpmm_knowledge.embedding_dimension): {current_dim}") + print(f"- 测试文件路径: {EMBEDDING_TEST_FILE}") + + new_dim = input( + "\n如果你计划更换嵌入模型，请在此输入“新的嵌入维度”（仅用于记录与提示，回车则跳过）：" + ).strip() + if new_dim and not new_dim.isdigit(): + print("输入的维度不是纯数字，已取消操作。") + return + + print( + "\n[重要提示]\n" + "- 修改嵌入模型或维度会导致当前磁盘中的旧知识库（data/embedding 下的向量）与新模型不兼容；\n" + "- 这通常意味着你需要清空旧的向量/图数据，并重新执行 LPMM 导入流水线；\n" + "- 请仅在你**确定要切换嵌入模型/维度**时再继续。\n" + ) + confirm = input("是否已充分评估风险，并准备切换嵌入模型/维度？(y/N): ").strip().lower() + if confirm != "y": + print("已根据你的选择取消嵌入模型迁移辅助操作。") + return + + print( + "\n接下来请手动完成以下操作（脚本不会自动修改配置或删除知识库）：\n" + f"1. 在配置文件中，将 lpmm_knowledge.embedding_dimension 从 {current_dim} 修改为你计划使用的新维度" + + (f"（例如 {new_dim}）" if new_dim else "") # 仅作为示例 + + "；\n" + "2. 根据需要，清空 data/embedding 与相关 KG 数据（data/rag 等），然后重新执行导入流水线；\n" + "3. 本脚本将帮助你归档当前的 embedding_model_test.json，避免旧测试文件干扰新模型的校验。\n" + ) + + # 2. 归档 embedding_model_test.json + test_path = Path(EMBEDDING_TEST_FILE) + if not test_path.exists(): + print(f"\n[INFO] 未在 {test_path} 发现 embedding_model_test.json，无需归档。") + return + + ts = datetime.now().strftime("%Y%m%d-%H%M%S") + archive_name = f"embedding_model_test-{safe_model_name}-{ts}.json" + archive_path = test_path.with_name(archive_name) + + # 若不巧重名，简单追加后缀避免覆盖 + suffix_id = 1 + while archive_path.exists(): + archive_name = f"embedding_model_test-{safe_model_name}-{ts}-{suffix_id}.json" + archive_path = test_path.with_name(archive_name) + suffix_id += 1 + + try: + test_path.rename(archive_path) + except Exception as exc: # pragma: no cover - 防御性兜底 + logger.error("归档 embedding_model_test.json 失败: %s", exc) + print(f"[ERROR] 归档 embedding_model_test.json 失败，请检查文件权限与路径。错误详情已写入日志。") + return + + print( + f"\n[OK] 已将 {test_path.name} 重命名为 {archive_path.name}。\n" + f"- 归档位置: {archive_path}\n" + "- 之后再次运行涉及嵌入模型的一致性校验时，将会基于当前配置与新模型生成新的测试文件。\n" + "- 在完成配置修改与知识库重导入前，请不要手动再创建名为 embedding_model_test.json 的文件。" + ) + + +def parse_args(argv: Optional[list[str]] = None) -> tuple[argparse.Namespace, List[str]]: + parser = argparse.ArgumentParser( + description=( + "LPMM 管理脚本：集中入口管理 LPMM 的导入 / 删除 / 自检 / 刷新 / 测试等功能。\n" + "可以通过 --interactive 进入菜单模式，也可以使用 --action 直接执行单个操作。" + ) + ) + parser.add_argument( + "-i", + "--interactive", + action="store_true", + help="进入交互式菜单模式（推荐给手动运维使用）", + ) + parser.add_argument( + "-a", + "--action", + choices=list(ACTION_INFO.keys()), + help="直接执行指定操作（非交互模式）", + ) + parser.add_argument( + "--non-interactive", + action="store_true", + help=( + "启用非交互模式：lpmm_manager 自身不会再通过 input() 询问是否继续前置检查；" + "并会将 --non-interactive 透传给子脚本，以避免子脚本中的交互式确认。" + ), + ) + # 允许在管理脚本之后继续跟随子脚本参数，例如: + # python lpmm_manager.py -a delete -- --hash-file xxx --yes + args, unknown = parser.parse_known_args(argv) + return args, unknown + + +def main(argv: Optional[list[str]] = None) -> None: + args, extra_args = parse_args(argv) + + # 如果指定了 non-interactive，则不能进入交互式菜单 + if args.non_interactive and args.interactive: + logger.error("不能同时指定 --interactive 与 --non-interactive，请二选一。") + sys.exit(1) + + # 没有指定 action 或显式要求交互 -> 进入菜单 + if args.interactive or not args.action: + interactive_loop() + return + + # 在非交互模式下，将 --non-interactive 透传给子脚本，避免其内部出现 input() 交互 + if args.non_interactive: + extra_args = ["--non-interactive"] + extra_args + + # 非交互模式：直接执行指定操作 + run_action(args.action, extra_args=extra_args) + + +if __name__ == "__main__": + main() + + diff --git a/scripts/raw_data_preprocessor.py b/scripts/raw_data_preprocessor.py index b5762198..6cca59d3 100644 --- a/scripts/raw_data_preprocessor.py +++ b/scripts/raw_data_preprocessor.py @@ -1,9 +1,9 @@ import os from pathlib import Path import sys # 新增系统模块导入 -from src.chat.knowledge.utils.hash import get_sha256 sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))) +from src.chat.knowledge.utils.hash import get_sha256 from src.common.logger import get_logger logger = get_logger("lpmm") @@ -59,10 +59,11 @@ def load_raw_data() -> tuple[list[str], list[str]]: - raw_data: 原始数据列表 - sha256_list: 原始数据的SHA256集合 """ - raw_data = _process_multi_files() + raw_paragraphs = _process_multi_files() sha256_list = [] sha256_set = set() - for item in raw_data: + raw_data: list[str] = [] + for item in raw_paragraphs: if not isinstance(item, str): logger.warning(f"数据类型错误：{item}") continue diff --git a/scripts/refresh_lpmm_knowledge.py b/scripts/refresh_lpmm_knowledge.py new file mode 100644 index 00000000..e70093a8 --- /dev/null +++ b/scripts/refresh_lpmm_knowledge.py @@ -0,0 +1,66 @@ +import os +import sys + +try: + if hasattr(sys.stdout, "reconfigure"): + sys.stdout.reconfigure(encoding="utf-8") + if hasattr(sys.stderr, "reconfigure"): + sys.stderr.reconfigure(encoding="utf-8") +except Exception: + pass + +# 确保能导入 src.* +sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))) + +from src.common.logger import get_logger +from src.config.config import global_config +from src.chat.knowledge import lpmm_start_up, get_qa_manager + +logger = get_logger("refresh_lpmm_knowledge") + + +def main() -> None: + logger.info("开始刷新 LPMM 知识库（重新加载向量库与 KG）...") + + if not global_config.lpmm_knowledge.enable: + logger.warning( + "当前配置中 lpmm_knowledge.enable = false，本次仅刷新磁盘数据与内存结构，" + "但聊天侧如未启用 LPMM 仍不会在问答中使用知识库。" + ) + + # 调用标准启动逻辑，内部会加载 data/embedding 与 data/rag + lpmm_start_up() + + qa_manager = get_qa_manager() + if qa_manager is None: + logger.error("刷新后 qa_manager 仍为 None，请检查是否已经成功导入过 LPMM 知识库。") + return + + # 简要输出当前知识库规模，方便人工确认 + embed_manager = qa_manager.embed_manager + kg_manager = qa_manager.kg_manager + + para_vec = len(embed_manager.paragraphs_embedding_store.store) + ent_vec = len(embed_manager.entities_embedding_store.store) + rel_vec = len(embed_manager.relation_embedding_store.store) + nodes = len(kg_manager.graph.get_node_list()) + edges = len(kg_manager.graph.get_edge_list()) + + logger.info("LPMM 知识库刷新完成，当前规模：") + logger.info( + "段落向量=%d, 实体向量=%d, 关系向量=%d, KG节点=%d, KG边=%d", + para_vec, + ent_vec, + rel_vec, + nodes, + edges, + ) + + print("\n[REFRESH] 刷新完成，请注意：") + print("- 本脚本是在独立进程内执行的，用于验证磁盘数据可以正常加载。") + print("- 若主程序已在运行且未在内部调用 lpmm_start_up() 重新初始化，仍需重启或新增管理入口来热刷新。") + print("- 如果不清楚 lpmm_start_up 是什么，只需要重启主程序即可。") + + +if __name__ == "__main__": + main() diff --git a/scripts/replyer_action_stats.py b/scripts/replyer_action_stats.py new file mode 100644 index 00000000..8d8904bf --- /dev/null +++ b/scripts/replyer_action_stats.py @@ -0,0 +1,303 @@ +""" +统计和展示 replyer 动作选择记录 + +用法: + python scripts/replyer_action_stats.py +""" + +import json +import os +import sys +from collections import Counter, defaultdict +from datetime import datetime +from typing import Dict, List, Any +from pathlib import Path + +# Add project root to Python path +project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) +sys.path.insert(0, project_root) + +try: + from src.common.database.database_model import ChatStreams + from src.chat.message_receive.chat_stream import get_chat_manager +except ImportError: + ChatStreams = None + get_chat_manager = None + + +def get_chat_name(chat_id: str) -> str: + """根据 chat_id 获取聊天名称""" + try: + if ChatStreams: + chat_stream = ChatStreams.get_or_none(ChatStreams.stream_id == chat_id) + if chat_stream: + if chat_stream.group_name: + return f"{chat_stream.group_name}" + elif chat_stream.user_nickname: + return f"{chat_stream.user_nickname}的私聊" + + if get_chat_manager: + chat_manager = get_chat_manager() + stream_name = chat_manager.get_stream_name(chat_id) + if stream_name: + return stream_name + + return f"未知聊天 ({chat_id[:8]}...)" + except Exception: + return f"查询失败 ({chat_id[:8]}...)" + + +def load_records(temp_dir: str = "data/temp") -> List[Dict[str, Any]]: + """加载所有 replyer 动作记录""" + records = [] + temp_path = Path(temp_dir) + + if not temp_path.exists(): + print(f"目录不存在: {temp_dir}") + return records + + # 查找所有 replyer_action_*.json 文件 + pattern = "replyer_action_*.json" + for file_path in temp_path.glob(pattern): + try: + with open(file_path, "r", encoding="utf-8") as f: + data = json.load(f) + records.append(data) + except Exception as e: + print(f"读取文件失败 {file_path}: {e}") + + # 按时间戳排序 + records.sort(key=lambda x: x.get("timestamp", "")) + return records + + +def format_timestamp(ts: str) -> str: + """格式化时间戳""" + try: + dt = datetime.fromisoformat(ts) + return dt.strftime("%Y-%m-%d %H:%M:%S") + except Exception: + return ts + + +def calculate_time_distribution(records: List[Dict[str, Any]]) -> Dict[str, int]: + """计算时间分布""" + now = datetime.now() + distribution = { + "今天": 0, + "昨天": 0, + "3天内": 0, + "7天内": 0, + "30天内": 0, + "更早": 0, + } + + for record in records: + try: + ts = record.get("timestamp", "") + if not ts: + continue + dt = datetime.fromisoformat(ts) + diff = (now - dt).days + + if diff == 0: + distribution["今天"] += 1 + elif diff == 1: + distribution["昨天"] += 1 + elif diff < 3: + distribution["3天内"] += 1 + elif diff < 7: + distribution["7天内"] += 1 + elif diff < 30: + distribution["30天内"] += 1 + else: + distribution["更早"] += 1 + except Exception: + pass + + return distribution + + +def print_statistics(records: List[Dict[str, Any]]): + """打印统计信息""" + if not records: + print("没有找到任何记录") + return + + print("=" * 80) + print("Replyer 动作选择记录统计") + print("=" * 80) + print() + + # 总记录数 + total_count = len(records) + print(f"📊 总记录数: {total_count}") + print() + + # 时间范围 + timestamps = [r.get("timestamp", "") for r in records if r.get("timestamp")] + if timestamps: + first_time = format_timestamp(min(timestamps)) + last_time = format_timestamp(max(timestamps)) + print(f"📅 时间范围: {first_time} ~ {last_time}") + print() + + # 按 think_level 统计 + think_levels = [r.get("think_level", 0) for r in records] + think_level_counter = Counter(think_levels) + print("🧠 思考深度分布:") + for level in sorted(think_level_counter.keys()): + count = think_level_counter[level] + percentage = (count / total_count) * 100 + level_name = {0: "不需要思考", 1: "简单思考", 2: "深度思考"}.get(level, f"未知({level})") + print(f" Level {level} ({level_name}): {count} 次 ({percentage:.1f}%)") + print() + + # 按 chat_id 统计（总体） + chat_counter = Counter([r.get("chat_id", "未知") for r in records]) + print(f"💬 聊天分布 (共 {len(chat_counter)} 个聊天):") + # 只显示前10个 + for chat_id, count in chat_counter.most_common(10): + chat_name = get_chat_name(chat_id) + percentage = (count / total_count) * 100 + print(f" {chat_name}: {count} 次 ({percentage:.1f}%)") + if len(chat_counter) > 10: + print(f" ... 还有 {len(chat_counter) - 10} 个聊天") + print() + + # 每个 chat_id 的详细统计 + print("=" * 80) + print("每个聊天的详细统计") + print("=" * 80) + print() + + # 按 chat_id 分组记录 + records_by_chat = defaultdict(list) + for record in records: + chat_id = record.get("chat_id", "未知") + records_by_chat[chat_id].append(record) + + # 按记录数排序 + sorted_chats = sorted(records_by_chat.items(), key=lambda x: len(x[1]), reverse=True) + + for chat_id, chat_records in sorted_chats: + chat_name = get_chat_name(chat_id) + chat_count = len(chat_records) + chat_percentage = (chat_count / total_count) * 100 + + print(f"📱 {chat_name} ({chat_id[:8]}...)") + print(f" 总记录数: {chat_count} ({chat_percentage:.1f}%)") + + # 该聊天的 think_level 分布 + chat_think_levels = [r.get("think_level", 0) for r in chat_records] + chat_think_counter = Counter(chat_think_levels) + print(" 思考深度分布:") + for level in sorted(chat_think_counter.keys()): + level_count = chat_think_counter[level] + level_percentage = (level_count / chat_count) * 100 + level_name = {0: "不需要思考", 1: "简单思考", 2: "深度思考"}.get(level, f"未知({level})") + print(f" Level {level} ({level_name}): {level_count} 次 ({level_percentage:.1f}%)") + + # 该聊天的时间范围 + chat_timestamps = [r.get("timestamp", "") for r in chat_records if r.get("timestamp")] + if chat_timestamps: + first_time = format_timestamp(min(chat_timestamps)) + last_time = format_timestamp(max(chat_timestamps)) + print(f" 时间范围: {first_time} ~ {last_time}") + + # 该聊天的时间分布 + chat_time_dist = calculate_time_distribution(chat_records) + print(" 时间分布:") + for period, count in chat_time_dist.items(): + if count > 0: + period_percentage = (count / chat_count) * 100 + print(f" {period}: {count} 次 ({period_percentage:.1f}%)") + + # 显示该聊天最近的一条理由示例 + if chat_records: + latest_record = chat_records[-1] + reason = latest_record.get("reason", "无理由") + if len(reason) > 120: + reason = reason[:120] + "..." + timestamp = format_timestamp(latest_record.get("timestamp", "")) + think_level = latest_record.get("think_level", 0) + print(f" 最新记录 [{timestamp}] (Level {think_level}): {reason}") + + print() + + # 时间分布 + time_dist = calculate_time_distribution(records) + print("⏰ 时间分布:") + for period, count in time_dist.items(): + if count > 0: + percentage = (count / total_count) * 100 + print(f" {period}: {count} 次 ({percentage:.1f}%)") + print() + + # 显示一些示例理由 + print("📝 示例理由 (最近5条):") + recent_records = records[-5:] + for i, record in enumerate(recent_records, 1): + reason = record.get("reason", "无理由") + think_level = record.get("think_level", 0) + timestamp = format_timestamp(record.get("timestamp", "")) + chat_id = record.get("chat_id", "未知") + chat_name = get_chat_name(chat_id) + + # 截断过长的理由 + if len(reason) > 100: + reason = reason[:100] + "..." + + print(f" {i}. [{timestamp}] {chat_name} (Level {think_level})") + print(f" {reason}") + print() + + # 按 think_level 分组显示理由示例 + print("=" * 80) + print("按思考深度分类的示例理由") + print("=" * 80) + print() + + for level in [0, 1, 2]: + level_records = [r for r in records if r.get("think_level") == level] + if not level_records: + continue + + level_name = {0: "不需要思考", 1: "简单思考", 2: "深度思考"}.get(level, f"未知({level})") + print(f"Level {level} ({level_name}) - 共 {len(level_records)} 条:") + + # 显示3个示例（选择最近的） + examples = level_records[-3:] if len(level_records) >= 3 else level_records + for i, record in enumerate(examples, 1): + reason = record.get("reason", "无理由") + if len(reason) > 150: + reason = reason[:150] + "..." + timestamp = format_timestamp(record.get("timestamp", "")) + chat_id = record.get("chat_id", "未知") + chat_name = get_chat_name(chat_id) + print(f" {i}. [{timestamp}] {chat_name}") + print(f" {reason}") + print() + + # 统计信息汇总 + print("=" * 80) + print("统计汇总") + print("=" * 80) + print(f"总记录数: {total_count}") + print(f"涉及聊天数: {len(chat_counter)}") + if chat_counter: + avg_count = total_count / len(chat_counter) + print(f"平均每个聊天记录数: {avg_count:.1f}") + else: + print("平均每个聊天记录数: N/A") + print() + + +def main(): + """主函数""" + records = load_records() + print_statistics(records) + + +if __name__ == "__main__": + main() diff --git a/scripts/test_lpmm_retrieval.py b/scripts/test_lpmm_retrieval.py new file mode 100644 index 00000000..c6aeccda --- /dev/null +++ b/scripts/test_lpmm_retrieval.py @@ -0,0 +1,122 @@ +import argparse +import asyncio +import os +import sys +from typing import List, Dict, Any, Optional + +# 强制使用 utf-8，避免控制台编码报错影响 Embedding 加载 +try: + if hasattr(sys.stdout, "reconfigure"): + sys.stdout.reconfigure(encoding="utf-8") + if hasattr(sys.stderr, "reconfigure"): + sys.stderr.reconfigure(encoding="utf-8") +except Exception: + pass + +# 确保能导入 src.* +sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))) + +from src.common.logger import get_logger +from src.config.config import global_config +from src.chat.knowledge import lpmm_start_up +from src.memory_system.retrieval_tools.query_lpmm_knowledge import query_lpmm_knowledge + +logger = get_logger("test_lpmm_retrieval") + + +DEFAULT_TEST_CASES: List[Dict[str, Any]] = [ + { + "name": "回滚一批知识", + "query": "LPMM是什么?", + "expect_keywords": ["哈希列表", "删除脚本", "OpenIE"], + }, + { + "name": "调整 LPMM 检索参数", + "query": "不同用词习惯带来的检索偏差该如何解决", + "expect_keywords": ["bot_config.toml", "lpmm_knowledge", "qa_paragraph_search_top_k"], + }, +] + + +async def run_tests(test_cases: Optional[List[Dict[str, Any]]] = None) -> None: + """简单测试 LPMM 知识库检索能力""" + if not global_config.lpmm_knowledge.enable: + logger.warning("当前配置中 lpmm_knowledge.enable 为 False，检索测试可能直接返回“未启用”。") + + logger.info("开始初始化 LPMM 知识库...") + lpmm_start_up() + logger.info("LPMM 知识库初始化完成，开始执行测试用例。") + + cases = test_cases if test_cases is not None else DEFAULT_TEST_CASES + + for case in cases: + name = case["name"] + query = case["query"] + expect_keywords: List[str] = case.get("expect_keywords", []) + + print("\n" + "=" * 60) + print(f"[TEST] {name}") + print(f"[Q] {query}") + + result = await query_lpmm_knowledge(query, limit=3) + + print("\n[RAW RESULT]") + print(result) + + status = "UNKNOWN" + hit_keywords: List[str] = [] + + if isinstance(result, str): + if "未启用" in result or "未初始化" in result or "查询失败" in result: + status = "ERROR" + elif "未找到与" in result: + status = "NO_HIT" + else: + if expect_keywords: + hit_keywords = [kw for kw in expect_keywords if kw in result] + status = "PASS" if hit_keywords else "WARN" + else: + status = "PASS" + + print("\n[CHECK]") + print(f"Status: {status}") + if expect_keywords: + print(f"Expected keywords: {expect_keywords}") + print(f"Hit keywords: {hit_keywords}") + + print("\n" + "=" * 60) + print("LPMM 检索测试完成。请根据每条用例的 Status 和命中关键词判断检索效果是否符合预期。") + + +def main() -> None: + parser = argparse.ArgumentParser( + description=( + "测试 LPMM 知识库检索能力。\n" + "如不提供参数，则执行内置的默认用例；\n" + "也可以通过 --query 与 --expect-keyword 自定义一条测试用例。" + ) + ) + parser.add_argument( + "--query", + help="自定义测试问题（单条）。提供该参数时，将仅运行这一条用例。", + ) + parser.add_argument( + "--expect-keyword", + action="append", + help="期望在检索结果中出现的关键字，可重复多次指定；仅在提供 --query 时生效。", + ) + args = parser.parse_args() + + if args.query: + custom_case = { + "name": "custom", + "query": args.query, + "expect_keywords": args.expect_keyword or [], + } + asyncio.run(run_tests([custom_case])) + else: + asyncio.run(run_tests()) + + +if __name__ == "__main__": + main() diff --git a/src/bw_learner/expression_learner.py b/src/bw_learner/expression_learner.py new file mode 100644 index 00000000..32a98f44 --- /dev/null +++ b/src/bw_learner/expression_learner.py @@ -0,0 +1,794 @@ +import time +import json +import os +import re +import asyncio +from typing import List, Optional, Tuple, Any, Dict +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 ( + 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 +from src.bw_learner.learner_utils import ( + filter_message_content, + is_bot_message, + build_context_paragraph, + contains_bot_self_name, + calculate_style_similarity, +) +from src.bw_learner.jargon_miner import miner_manager +from json_repair import repair_json + + +# MAX_EXPRESSION_COUNT = 300 + +logger = get_logger("expressor") + + +def init_prompt() -> None: + learn_style_prompt = """{chat_str} +你的名字是{bot_name},现在请你完成两个提取任务 +任务1：请从上面这段群聊中用户的语言风格和说话方式 +1. 只考虑文字，不要考虑表情包和图片 +2. 不要总结SELF的发言，因为这是你自己的发言，不要重复学习你自己的发言 +3. 不要涉及具体的人名，也不要涉及具体名词 +4. 思考有没有特殊的梗，一并总结成语言风格 +5. 例子仅供参考，请严格根据群聊内容总结!!! +注意：总结成如下格式的规律，总结的内容要详细，但具有概括性： +例如：当"AAAAA"时，可以"BBBBB", AAAAA代表某个场景，不超过20个字。BBBBB代表对应的语言风格，特定句式或表达方式，不超过20个字。 +表达方式在3-5个左右，不要超过10个 + + +任务2：请从上面这段聊天内容中提取"可能是黑话"的候选项（黑话/俚语/网络缩写/口头禅）。 +- 必须为对话中真实出现过的短词或短语 +- 必须是你无法理解含义的词语，没有明确含义的词语，请不要选择有明确含义，或者含义清晰的词语 +- 排除：人名、@、表情包/图片中的内容、纯标点、常规功能词（如的、了、呢、啊等） +- 每个词条长度建议 2-8 个字符（不强制），尽量短小 +- 请你提取出可能的黑话，最多30个黑话，请尽量提取所有 + +黑话必须为以下几种类型： +- 由字母构成的，汉语拼音首字母的简写词，例如：nb、yyds、xswl +- 英文词语的缩写，用英文字母概括一个词汇或含义，例如：CPU、GPU、API +- 中文词语的缩写，用几个汉字概括一个词汇或含义，例如：社死、内卷 + +输出要求： +将表达方式，语言风格和黑话以 JSON 数组输出，每个元素为一个对象，结构如下（注意字段名）： +注意请不要输出重复内容，请对表达方式和黑话进行去重。 + +[ + {{"situation": "AAAAA", "style": "BBBBB", "source_id": "3"}}, + {{"situation": "CCCC", "style": "DDDD", "source_id": "7"}} + {{"situation": "对某件事表示十分惊叹", "style": "使用 我嘞个xxxx", "source_id": "[消息编号]"}}, + {{"situation": "表示讽刺的赞同，不讲道理", "style": "对对对", "source_id": "[消息编号]"}}, + {{"situation": "当涉及游戏相关时，夸赞，略带戏谑意味", "style": "使用 这么强！", "source_id": "[消息编号]"}}, + {{"content": "词条", "source_id": "12"}}, + {{"content": "词条2", "source_id": "5"}} +] + +其中： +表达方式条目： +- situation：表示“在什么情境下”的简短概括（不超过20个字） +- style：表示对应的语言风格或常用表达（不超过20个字） +- source_id：该表达方式对应的“来源行编号”，即上方聊天记录中方括号里的数字（例如 [3]），请只输出数字本身，不要包含方括号 +黑话jargon条目： +- content:表示黑话的内容 +- source_id：该黑话对应的“来源行编号”，即上方聊天记录中方括号里的数字（例如 [3]），请只输出数字本身，不要包含方括号 + +现在请你输出 JSON： +""" + 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.utils, request_type="expression.learner" + ) + self.summary_model: LLMRequest = LLMRequest( + model_set=model_config.model_task_config.utils_small, request_type="expression.summary" + ) + 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 + + # 学习锁，防止并发执行学习任务 + self._learning_lock = asyncio.Lock() + + async def learn_and_store( + self, + messages: List[Any], + ) -> List[Tuple[str, str, str]]: + """ + 学习并存储表达方式 + + Args: + messages: 外部传入的消息列表（必需） + num: 学习数量 + timestamp_start: 学习开始的时间戳，如果为None则使用self.last_learning_time + """ + if not messages: + return None + + random_msg = messages + + # 学习用（开启行编号，便于溯源） + random_msg_str: str = await build_anonymous_messages(random_msg, show_ids=True) + + prompt: str = await global_prompt_manager.format_prompt( + "learn_style_prompt", + bot_name=global_config.bot.nickname, + 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 + + # 解析 LLM 返回的表达方式列表和黑话列表（包含来源行编号） + expressions: List[Tuple[str, str, str]] + jargon_entries: List[Tuple[str, str]] # (content, source_id) + expressions, jargon_entries = self.parse_expression_response(response) + expressions = self._filter_self_reference_styles(expressions) + + # 检查表达方式数量，如果超过10个则放弃本次表达学习 + if len(expressions) > 10: + logger.info(f"表达方式提取数量超过10个（实际{len(expressions)}个），放弃本次表达学习") + expressions = [] + + # 检查黑话数量，如果超过30个则放弃本次黑话学习 + if len(jargon_entries) > 30: + logger.info(f"黑话提取数量超过30个（实际{len(jargon_entries)}个），放弃本次黑话学习") + jargon_entries = [] + + # 处理黑话条目，路由到 jargon_miner（即使没有表达方式也要处理黑话） + if jargon_entries: + await self._process_jargon_entries(jargon_entries, random_msg) + + # 如果没有表达方式，直接返回 + if not expressions: + logger.info("过滤后没有可用的表达方式（style 与机器人名称重复）") + return [] + + logger.info(f"学习的prompt: {prompt}") + logger.info(f"学习的expressions: {expressions}") + logger.info(f"学习的jargon_entries: {jargon_entries}") + logger.info(f"学习的response: {response}") + + # 直接根据 source_id 在 random_msg 中溯源，获取 context + filtered_expressions: List[Tuple[str, str, str]] = [] # (situation, style, context) + + for situation, style, source_id in expressions: + source_id_str = (source_id or "").strip() + if not source_id_str.isdigit(): + # 无效的来源行编号，跳过 + continue + + line_index = int(source_id_str) - 1 # build_anonymous_messages 的编号从 1 开始 + if line_index < 0 or line_index >= len(random_msg): + # 超出范围，跳过 + continue + + # 当前行的原始内容 + current_msg = random_msg[line_index] + + # 过滤掉从bot自己发言中提取到的表达方式 + if is_bot_message(current_msg): + continue + + context = filter_message_content(current_msg.processed_plain_text or "") + if not context: + continue + + # 过滤掉包含 SELF 的内容（不学习） + if "SELF" in (situation or "") or "SELF" in (style or "") or "SELF" in context: + logger.info( + f"跳过包含 SELF 的表达方式: situation={situation}, style={style}, source_id={source_id}" + ) + continue + + filtered_expressions.append((situation, style, context)) + + learnt_expressions = filtered_expressions + + if learnt_expressions is None: + logger.info("没有学习到表达风格") + return [] + + # 展示学到的表达方式 + learnt_expressions_str = "" + for ( + situation, + style, + _context, + ) 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 表 + for ( + situation, + style, + context, + ) in learnt_expressions: + await self._upsert_expression_record( + situation=situation, + style=style, + context=context, + current_time=current_time, + ) + + return learnt_expressions + + def parse_expression_response(self, response: str) -> Tuple[List[Tuple[str, str, str]], List[Tuple[str, str]]]: + """ + 解析 LLM 返回的表达风格总结和黑话 JSON，提取两个列表。 + + 期望的 JSON 结构： + [ + {"situation": "AAAAA", "style": "BBBBB", "source_id": "3"}, // 表达方式 + {"content": "词条", "source_id": "12"}, // 黑话 + ... + ] + + Returns: + Tuple[List[Tuple[str, str, str]], List[Tuple[str, str]]]: + 第一个列表是表达方式 (situation, style, source_id) + 第二个列表是黑话 (content, source_id) + """ + if not response: + return [], [] + + raw = response.strip() + + # 尝试提取 ```json 代码块 + json_block_pattern = r"```json\s*(.*?)\s*```" + match = re.search(json_block_pattern, raw, re.DOTALL) + if match: + raw = match.group(1).strip() + else: + # 去掉可能存在的通用 ``` 包裹 + raw = re.sub(r"^```\s*", "", raw, flags=re.MULTILINE) + raw = re.sub(r"```\s*$", "", raw, flags=re.MULTILINE) + raw = raw.strip() + + parsed = None + expressions: List[Tuple[str, str, str]] = [] # (situation, style, source_id) + jargon_entries: List[Tuple[str, str]] = [] # (content, source_id) + + try: + # 优先尝试直接解析 + if raw.startswith("[") and raw.endswith("]"): + parsed = json.loads(raw) + else: + repaired = repair_json(raw) + if isinstance(repaired, str): + parsed = json.loads(repaired) + else: + parsed = repaired + except Exception as parse_error: + # 如果解析失败，尝试修复中文引号问题 + # 使用状态机方法，在 JSON 字符串值内部将中文引号替换为转义的英文引号 + try: + + def fix_chinese_quotes_in_json(text): + """使用状态机修复 JSON 字符串值中的中文引号""" + result = [] + i = 0 + in_string = False + escape_next = False + + while i < len(text): + char = text[i] + + if escape_next: + # 当前字符是转义字符后的字符，直接添加 + result.append(char) + escape_next = False + i += 1 + continue + + if char == "\\": + # 转义字符 + result.append(char) + escape_next = True + i += 1 + continue + + if char == '"' and not escape_next: + # 遇到英文引号，切换字符串状态 + in_string = not in_string + result.append(char) + i += 1 + continue + + if in_string: + # 在字符串值内部，将中文引号替换为转义的英文引号 + if char == '"': # 中文左引号 U+201C + result.append('\\"') + elif char == '"': # 中文右引号 U+201D + result.append('\\"') + else: + result.append(char) + else: + # 不在字符串内，直接添加 + result.append(char) + + i += 1 + + return "".join(result) + + fixed_raw = fix_chinese_quotes_in_json(raw) + + # 再次尝试解析 + if fixed_raw.startswith("[") and fixed_raw.endswith("]"): + parsed = json.loads(fixed_raw) + else: + repaired = repair_json(fixed_raw) + if isinstance(repaired, str): + parsed = json.loads(repaired) + else: + parsed = repaired + except Exception as fix_error: + logger.error(f"解析表达风格 JSON 失败，初始错误: {type(parse_error).__name__}: {str(parse_error)}") + logger.error(f"修复中文引号后仍失败，错误: {type(fix_error).__name__}: {str(fix_error)}") + logger.error(f"解析表达风格 JSON 失败，原始响应：{response}") + logger.error(f"处理后的 JSON 字符串（前500字符）：{raw[:500]}") + return [], [] + + if isinstance(parsed, dict): + parsed_list = [parsed] + elif isinstance(parsed, list): + parsed_list = parsed + else: + logger.error(f"表达风格解析结果类型异常: {type(parsed)}, 内容: {parsed}") + return [], [] + + for item in parsed_list: + if not isinstance(item, dict): + continue + + # 检查是否是表达方式条目（有 situation 和 style） + situation = str(item.get("situation", "")).strip() + style = str(item.get("style", "")).strip() + source_id = str(item.get("source_id", "")).strip() + + if situation and style and source_id: + # 表达方式条目 + expressions.append((situation, style, source_id)) + elif item.get("content"): + # 黑话条目（有 content 字段） + content = str(item.get("content", "")).strip() + source_id = str(item.get("source_id", "")).strip() + if content and source_id: + jargon_entries.append((content, source_id)) + + return expressions, jargon_entries + + def _filter_self_reference_styles(self, expressions: List[Tuple[str, str, str]]) -> List[Tuple[str, str, str]]: + """ + 过滤掉style与机器人名称/昵称重复的表达 + """ + banned_names = set() + bot_nickname = (global_config.bot.nickname or "").strip() + if bot_nickname: + banned_names.add(bot_nickname) + + alias_names = global_config.bot.alias_names or [] + for alias in alias_names: + alias = alias.strip() + if alias: + banned_names.add(alias) + + banned_casefold = {name.casefold() for name in banned_names if name} + + filtered: List[Tuple[str, str, str]] = [] + removed_count = 0 + for situation, style, source_id in expressions: + normalized_style = (style or "").strip() + if normalized_style and normalized_style.casefold() not in banned_casefold: + filtered.append((situation, style, source_id)) + else: + removed_count += 1 + + if removed_count: + logger.debug(f"已过滤 {removed_count} 条style与机器人名称重复的表达方式") + + return filtered + + async def _upsert_expression_record( + self, + situation: str, + style: str, + context: str, + current_time: float, + ) -> None: + # 第一层：检查是否有完全一致的 style（检查 style 字段和 style_list） + expr_obj = await self._find_exact_style_match(style) + + if expr_obj: + # 找到完全匹配的 style，合并到现有记录（不使用 LLM 总结） + await self._update_existing_expression( + expr_obj=expr_obj, + situation=situation, + style=style, + context=context, + current_time=current_time, + use_llm_summary=False, + ) + return + + # 第二层：检查是否有相似的 style（相似度 >= 0.75，检查 style 字段和 style_list） + similar_expr_obj = await self._find_similar_style_expression(style, similarity_threshold=0.75) + + if similar_expr_obj: + # 找到相似的 style，合并到现有记录（使用 LLM 总结） + await self._update_existing_expression( + expr_obj=similar_expr_obj, + situation=situation, + style=style, + context=context, + current_time=current_time, + use_llm_summary=True, + ) + return + + # 没有找到匹配的记录，创建新记录 + await self._create_expression_record( + situation=situation, + style=style, + context=context, + current_time=current_time, + ) + + async def _create_expression_record( + self, + situation: str, + style: str, + context: str, + current_time: float, + ) -> None: + content_list = [situation] + # 创建新记录时，直接使用原始的 situation，不进行总结 + formatted_situation = situation + + Expression.create( + situation=formatted_situation, + style=style, + content_list=json.dumps(content_list, ensure_ascii=False), + style_list=None, # 新记录初始时 style_list 为空 + count=1, + last_active_time=current_time, + chat_id=self.chat_id, + create_date=current_time, + context=context, + ) + + async def _update_existing_expression( + self, + expr_obj: Expression, + situation: str, + style: str, + context: str, + current_time: float, + use_llm_summary: bool = True, + ) -> None: + """ + 更新现有 Expression 记录（style 完全匹配或相似的情况） + 将新的 situation 添加到 content_list，将新的 style 添加到 style_list（如果不同） + + Args: + use_llm_summary: 是否使用 LLM 进行总结，完全匹配时为 False，相似匹配时为 True + """ + # 更新 content_list（添加新的 situation） + content_list = self._parse_content_list(expr_obj.content_list) + content_list.append(situation) + expr_obj.content_list = json.dumps(content_list, ensure_ascii=False) + + # 更新 style_list（如果 style 不同，添加到 style_list） + style_list = self._parse_style_list(expr_obj.style_list) + # 将原有的 style 也加入 style_list（如果还没有的话） + if expr_obj.style and expr_obj.style not in style_list: + style_list.append(expr_obj.style) + # 如果新的 style 不在 style_list 中，添加它 + if style not in style_list: + style_list.append(style) + expr_obj.style_list = json.dumps(style_list, ensure_ascii=False) + + # 更新其他字段 + expr_obj.count = (expr_obj.count or 0) + 1 + expr_obj.last_active_time = current_time + expr_obj.context = context + + if use_llm_summary: + # 相似匹配时，使用 LLM 重新组合 situation 和 style + new_situation = await self._compose_situation_text( + content_list=content_list, + count=expr_obj.count, + fallback=expr_obj.situation, + ) + expr_obj.situation = new_situation + + new_style = await self._compose_style_text( + style_list=style_list, + count=expr_obj.count, + fallback=expr_obj.style or style, + ) + expr_obj.style = new_style + else: + # 完全匹配时，不进行 LLM 总结，保持原有的 situation 和 style 不变 + # 只更新 content_list 和 style_list + pass + + expr_obj.save() + + def _parse_content_list(self, stored_list: Optional[str]) -> List[str]: + if not stored_list: + return [] + try: + data = json.loads(stored_list) + except json.JSONDecodeError: + return [] + return [str(item) for item in data if isinstance(item, str)] if isinstance(data, list) else [] + + def _parse_style_list(self, stored_list: Optional[str]) -> List[str]: + """解析 style_list JSON 字符串为列表，逻辑与 _parse_content_list 相同""" + if not stored_list: + return [] + try: + data = json.loads(stored_list) + except json.JSONDecodeError: + return [] + return [str(item) for item in data if isinstance(item, str)] if isinstance(data, list) else [] + + async def _find_exact_style_match(self, style: str) -> Optional[Expression]: + """ + 查找具有完全匹配 style 的 Expression 记录 + 只检查 style_list 中的每一项（不检查 style 字段，因为 style 可能是总结后的概括性描述） + + Args: + style: 要查找的 style + + Returns: + 找到的 Expression 对象，如果没有找到则返回 None + """ + # 查询同一 chat_id 的所有记录 + all_expressions = Expression.select().where(Expression.chat_id == self.chat_id) + + for expr in all_expressions: + # 只检查 style_list 中的每一项 + style_list = self._parse_style_list(expr.style_list) + if style in style_list: + return expr + + return None + + async def _find_similar_style_expression(self, style: str, similarity_threshold: float = 0.75) -> Optional[Expression]: + """ + 查找具有相似 style 的 Expression 记录 + 只检查 style_list 中的每一项（不检查 style 字段，因为 style 可能是总结后的概括性描述） + + Args: + style: 要查找的 style + similarity_threshold: 相似度阈值，默认 0.75 + + Returns: + 找到的最相似的 Expression 对象，如果没有找到则返回 None + """ + # 查询同一 chat_id 的所有记录 + all_expressions = Expression.select().where(Expression.chat_id == self.chat_id) + + best_match = None + best_similarity = 0.0 + + for expr in all_expressions: + # 只检查 style_list 中的每一项 + style_list = self._parse_style_list(expr.style_list) + for existing_style in style_list: + similarity = calculate_style_similarity(style, existing_style) + if similarity >= similarity_threshold and similarity > best_similarity: + best_similarity = similarity + best_match = expr + + if best_match: + logger.debug(f"找到相似的 style: 相似度={best_similarity:.3f}, 现有='{best_match.style}', 新='{style}'") + + return best_match + + async def _compose_situation_text(self, content_list: List[str], count: int, fallback: str = "") -> str: + sanitized = [c.strip() for c in content_list if c.strip()] + summary = await self._summarize_situations(sanitized) + if summary: + return summary + return "/".join(sanitized) if sanitized else fallback + + async def _compose_style_text(self, style_list: List[str], count: int, fallback: str = "") -> str: + """ + 组合 style 文本，如果 style_list 有多个元素则尝试总结 + """ + sanitized = [s.strip() for s in style_list if s.strip()] + if len(sanitized) > 1: + # 只有当有多个 style 时才尝试总结 + summary = await self._summarize_styles(sanitized) + if summary: + return summary + # 如果只有一个或总结失败，返回第一个或 fallback + return sanitized[0] if sanitized else fallback + + async def _summarize_styles(self, styles: List[str]) -> Optional[str]: + """总结多个 style，生成一个概括性的 style 描述""" + if not styles or len(styles) <= 1: + return None + + # 计算输入列表中最长项目的长度 + max_input_length = max(len(s) for s in styles) if styles else 0 + max_summary_length = max_input_length * 2 + + # 最多重试3次 + max_retries = 3 + retry_count = 0 + + while retry_count < max_retries: + # 如果是重试，在 prompt 中强调要更简洁 + length_hint = f"长度不超过{max_summary_length}个字符，" if retry_count > 0 else "长度不超过20个字，" + + prompt = ( + "请阅读以下多个语言风格/表达方式，对其进行总结。" + "不要对其进行语义概括，而是尽可能找出其中不变的部分或共同表达，尽量使用原文" + f"{length_hint}保留共同特点：\n" + f"{chr(10).join(f'- {s}' for s in styles[-10:])}\n只输出概括内容。不要输出其他内容" + ) + + try: + summary, _ = await self.summary_model.generate_response_async(prompt, temperature=0.2) + summary = summary.strip() + if summary: + # 检查总结长度是否超过限制 + if len(summary) <= max_summary_length: + return summary + else: + retry_count += 1 + logger.debug( + f"总结长度 {len(summary)} 超过限制 {max_summary_length} " + f"(输入最长项长度: {max_input_length})，重试第 {retry_count} 次" + ) + continue + except Exception as e: + logger.error(f"概括表达风格失败: {e}") + return None + + # 如果重试多次后仍然超过长度，返回 None（不进行总结） + logger.warning( + f"总结多次后仍超过长度限制，放弃总结。" + f"输入最长项长度: {max_input_length}, 最大允许长度: {max_summary_length}" + ) + return None + + async def _summarize_situations(self, situations: List[str]) -> Optional[str]: + if not situations: + return None + + prompt = ( + "请阅读以下多个聊天情境描述，并将它们概括成一句简短的话，" + "长度不超过20个字，保留共同特点：\n" + f"{chr(10).join(f'- {s}' for s in situations[-10:])}\n只输出概括内容。" + ) + + try: + summary, _ = await self.summary_model.generate_response_async(prompt, temperature=0.2) + summary = summary.strip() + if summary: + return summary + except Exception as e: + logger.error(f"概括表达情境失败: {e}") + return None + + async def _process_jargon_entries(self, jargon_entries: List[Tuple[str, str]], messages: List[Any]) -> None: + """ + 处理从 expression learner 提取的黑话条目，路由到 jargon_miner + + Args: + jargon_entries: 黑话条目列表，每个元素是 (content, source_id) + messages: 消息列表，用于构建上下文 + """ + if not jargon_entries or not messages: + return + + # 获取 jargon_miner 实例 + jargon_miner = miner_manager.get_miner(self.chat_id) + + # 构建黑话条目格式，与 jargon_miner.run_once 中的格式一致 + entries: List[Dict[str, List[str]]] = [] + + for content, source_id in jargon_entries: + content = content.strip() + if not content: + continue + + # 过滤掉包含 SELF 的黑话，不学习 + if "SELF" in content: + logger.info(f"跳过包含 SELF 的黑话: {content}") + continue + + # 检查是否包含机器人名称 + if contains_bot_self_name(content): + logger.info(f"跳过包含机器人昵称/别名的黑话: {content}") + continue + + # 解析 source_id + source_id_str = (source_id or "").strip() + if not source_id_str.isdigit(): + logger.warning(f"黑话条目 source_id 无效: content={content}, source_id={source_id_str}") + continue + + # build_anonymous_messages 的编号从 1 开始 + line_index = int(source_id_str) - 1 + if line_index < 0 or line_index >= len(messages): + logger.warning(f"黑话条目 source_id 超出范围: content={content}, source_id={source_id_str}") + continue + + # 检查是否是机器人自己的消息 + target_msg = messages[line_index] + if is_bot_message(target_msg): + logger.info(f"跳过引用机器人自身消息的黑话: content={content}, source_id={source_id_str}") + continue + + # 构建上下文段落 + context_paragraph = build_context_paragraph(messages, line_index) + if not context_paragraph: + logger.warning(f"黑话条目上下文为空: content={content}, source_id={source_id_str}") + continue + + entries.append({"content": content, "raw_content": [context_paragraph]}) + + if not entries: + return + + # 调用 jargon_miner 处理这些条目 + await jargon_miner.process_extracted_entries(entries) + + +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/bw_learner/expression_reflector.py b/src/bw_learner/expression_reflector.py new file mode 100644 index 00000000..c627b5b7 --- /dev/null +++ b/src/bw_learner/expression_reflector.py @@ -0,0 +1,250 @@ +import random +import time +from typing import Optional, Dict + +from src.common.logger import get_logger +from src.common.database.database_model import Expression +from src.config.config import global_config +from src.chat.message_receive.chat_stream import get_chat_manager +from src.plugin_system.apis import send_api + +logger = get_logger("expression_reflector") + + +class ExpressionReflector: + """表达反思器，管理单个聊天流的表达反思提问""" + + def __init__(self, chat_id: str): + self.chat_id = chat_id + self.last_ask_time: float = 0.0 + + async def check_and_ask(self) -> bool: + """ + 检查是否需要提问表达反思，如果需要则提问 + + Returns: + bool: 是否执行了提问 + """ + try: + logger.debug(f"[Expression Reflection] 开始检查是否需要提问 (stream_id: {self.chat_id})") + + if not global_config.expression.reflect: + logger.debug("[Expression Reflection] 表达反思功能未启用，跳过") + return False + + operator_config = global_config.expression.reflect_operator_id + if not operator_config: + logger.debug("[Expression Reflection] Operator ID 未配置，跳过") + return False + + # 检查是否在允许列表中 + allow_reflect = global_config.expression.allow_reflect + if allow_reflect: + # 将 allow_reflect 中的 platform:id:type 格式转换为 chat_id 列表 + allow_reflect_chat_ids = [] + for stream_config in allow_reflect: + parsed_chat_id = global_config.expression._parse_stream_config_to_chat_id(stream_config) + if parsed_chat_id: + allow_reflect_chat_ids.append(parsed_chat_id) + else: + logger.warning(f"[Expression Reflection] 无法解析 allow_reflect 配置项: {stream_config}") + + if self.chat_id not in allow_reflect_chat_ids: + logger.info(f"[Expression Reflection] 当前聊天流 {self.chat_id} 不在允许列表中，跳过") + return False + + # 检查上一次提问时间 + current_time = time.time() + time_since_last_ask = current_time - self.last_ask_time + + # 5-10分钟间隔，随机选择 + min_interval = 10 * 60 # 5分钟 + max_interval = 15 * 60 # 10分钟 + interval = random.uniform(min_interval, max_interval) + + logger.info( + f"[Expression Reflection] 上次提问时间: {self.last_ask_time:.2f}, 当前时间: {current_time:.2f}, 已过时间: {time_since_last_ask:.2f}秒 ({time_since_last_ask / 60:.2f}分钟), 需要间隔: {interval:.2f}秒 ({interval / 60:.2f}分钟)" + ) + + if time_since_last_ask < interval: + remaining_time = interval - time_since_last_ask + logger.info( + f"[Expression Reflection] 距离上次提问时间不足，还需等待 {remaining_time:.2f}秒 ({remaining_time / 60:.2f}分钟)，跳过" + ) + return False + + # 检查是否已经有针对该 Operator 的 Tracker 在运行 + logger.info(f"[Expression Reflection] 检查 Operator {operator_config} 是否已有活跃的 Tracker") + if await _check_tracker_exists(operator_config): + logger.info(f"[Expression Reflection] Operator {operator_config} 已有活跃的 Tracker，跳过本次提问") + return False + + # 获取未检查的表达 + try: + logger.info("[Expression Reflection] 查询未检查且未拒绝的表达") + expressions = Expression.select().where((~Expression.checked) & (~Expression.rejected)).limit(50) + + expr_list = list(expressions) + logger.info(f"[Expression Reflection] 找到 {len(expr_list)} 个候选表达") + + if not expr_list: + logger.info("[Expression Reflection] 没有可用的表达，跳过") + return False + + target_expr: Expression = random.choice(expr_list) + logger.info( + f"[Expression Reflection] 随机选择了表达 ID: {target_expr.id}, Situation: {target_expr.situation}, Style: {target_expr.style}" + ) + + # 生成询问文本 + ask_text = _generate_ask_text(target_expr) + if not ask_text: + logger.warning("[Expression Reflection] 生成询问文本失败，跳过") + return False + + logger.info(f"[Expression Reflection] 准备向 Operator {operator_config} 发送提问") + # 发送给 Operator + await _send_to_operator(operator_config, ask_text, target_expr) + + # 更新上一次提问时间 + self.last_ask_time = current_time + logger.info(f"[Expression Reflection] 提问成功，已更新上次提问时间为 {current_time:.2f}") + + return True + + except Exception as e: + logger.error(f"[Expression Reflection] 检查或提问过程中出错: {e}") + import traceback + + logger.error(traceback.format_exc()) + return False + except Exception as e: + logger.error(f"[Expression Reflection] 检查或提问过程中出错: {e}") + import traceback + + logger.error(traceback.format_exc()) + return False + + +class ExpressionReflectorManager: + """表达反思管理器，管理多个聊天流的表达反思实例""" + + def __init__(self): + self.reflectors: Dict[str, ExpressionReflector] = {} + + def get_or_create_reflector(self, chat_id: str) -> ExpressionReflector: + """获取或创建指定聊天流的表达反思实例""" + if chat_id not in self.reflectors: + self.reflectors[chat_id] = ExpressionReflector(chat_id) + return self.reflectors[chat_id] + + +# 创建全局实例 +expression_reflector_manager = ExpressionReflectorManager() + + +async def _check_tracker_exists(operator_config: str) -> bool: + """检查指定 Operator 是否已有活跃的 Tracker""" + from src.bw_learner.reflect_tracker import reflect_tracker_manager + + chat_manager = get_chat_manager() + chat_stream = None + + # 尝试解析配置字符串 "platform:id:type" + parts = operator_config.split(":") + if len(parts) == 3: + platform = parts[0] + id_str = parts[1] + stream_type = parts[2] + + user_info = None + group_info = None + + from maim_message import UserInfo, GroupInfo + + if stream_type == "group": + group_info = GroupInfo(group_id=id_str, platform=platform) + user_info = UserInfo(user_id="system", user_nickname="System", platform=platform) + elif stream_type == "private": + user_info = UserInfo(user_id=id_str, platform=platform, user_nickname="Operator") + else: + return False + + if user_info: + try: + chat_stream = await chat_manager.get_or_create_stream(platform, user_info, group_info) + except Exception as e: + logger.error(f"Failed to get or create chat stream for checking tracker: {e}") + return False + else: + chat_stream = chat_manager.get_stream(operator_config) + + if not chat_stream: + return False + + return reflect_tracker_manager.get_tracker(chat_stream.stream_id) is not None + + +def _generate_ask_text(expr: Expression) -> Optional[str]: + try: + ask_text = ( + f"我正在学习新的表达方式，请帮我看看这个是否合适？\n\n" + f"**学习到的表达信息**\n" + f"- 情景 (Situation): {expr.situation}\n" + f"- 风格 (Style): {expr.style}\n" + ) + return ask_text + except Exception as e: + logger.error(f"Failed to generate ask text: {e}") + return None + + +async def _send_to_operator(operator_config: str, text: str, expr: Expression): + chat_manager = get_chat_manager() + chat_stream = None + + # 尝试解析配置字符串 "platform:id:type" + parts = operator_config.split(":") + if len(parts) == 3: + platform = parts[0] + id_str = parts[1] + stream_type = parts[2] + + user_info = None + group_info = None + + from maim_message import UserInfo, GroupInfo + + if stream_type == "group": + group_info = GroupInfo(group_id=id_str, platform=platform) + user_info = UserInfo(user_id="system", user_nickname="System", platform=platform) + elif stream_type == "private": + user_info = UserInfo(user_id=id_str, platform=platform, user_nickname="Operator") + else: + logger.warning(f"Unknown stream type in operator config: {stream_type}") + return + + if user_info: + try: + chat_stream = await chat_manager.get_or_create_stream(platform, user_info, group_info) + except Exception as e: + logger.error(f"Failed to get or create chat stream for operator {operator_config}: {e}") + return + else: + chat_stream = chat_manager.get_stream(operator_config) + + if not chat_stream: + logger.warning(f"Could not find or create chat stream for operator: {operator_config}") + return + + stream_id = chat_stream.stream_id + + # 注册 Tracker + from src.bw_learner.reflect_tracker import ReflectTracker, reflect_tracker_manager + + tracker = ReflectTracker(chat_stream=chat_stream, expression=expr, created_time=time.time()) + reflect_tracker_manager.add_tracker(stream_id, tracker) + + # 发送消息 + await send_api.text_to_stream(text=text, stream_id=stream_id, typing=True) + logger.info(f"Sent expression reflect query to operator {operator_config} for expr {expr.id}") diff --git a/src/express/expression_selector.py b/src/bw_learner/expression_selector.py similarity index 56% rename from src/express/expression_selector.py rename to src/bw_learner/expression_selector.py index b4e25f36..4140d102 100644 --- a/src/express/expression_selector.py +++ b/src/bw_learner/expression_selector.py @@ -1,6 +1,5 @@ import json import time -import hashlib from typing import List, Dict, Optional, Any, Tuple from json_repair import repair_json @@ -10,7 +9,8 @@ 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.express_utils import weighted_sample +from src.bw_learner.learner_utils import weighted_sample +from src.chat.message_receive.chat_stream import get_chat_manager logger = get_logger("expression_selector") @@ -67,7 +67,7 @@ class ExpressionSelector: @staticmethod def _parse_stream_config_to_chat_id(stream_config_str: str) -> Optional[str]: - """解析'platform:id:type'为chat_id（与get_stream_id一致）""" + """解析'platform:id:type'为chat_id，直接使用 ChatManager 提供的接口""" try: parts = stream_config_str.split(":") if len(parts) != 3: @@ -76,12 +76,8 @@ class ExpressionSelector: 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() + # 统一通过 chat_manager 生成 stream_id，避免各处自行实现哈希逻辑 + return get_chat_manager().get_stream_id(platform, str(id_str), is_group=is_group) except Exception: return None @@ -111,6 +107,85 @@ class ExpressionSelector: return group_chat_ids return [chat_id] + def _select_expressions_simple(self, chat_id: str, max_num: int) -> Tuple[List[Dict[str, Any]], List[int]]: + """ + 简单模式：只选择 count > 1 的项目，要求至少有10个才进行选择，随机选5个，不进行LLM选择 + + Args: + chat_id: 聊天流ID + max_num: 最大选择数量（此参数在此模式下不使用，固定选择5个） + + Returns: + Tuple[List[Dict[str, Any]], List[int]]: 选中的表达方式列表和ID列表 + """ + try: + # 支持多chat_id合并抽选 + related_chat_ids = self.get_related_chat_ids(chat_id) + + # 查询所有相关chat_id的表达方式，排除 rejected=1 的，且只选择 count > 1 的 + style_query = Expression.select().where( + (Expression.chat_id.in_(related_chat_ids)) & (~Expression.rejected) & (Expression.count > 1) + ) + + 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, + "count": expr.count if getattr(expr, "count", None) is not None else 1, + "checked": expr.checked if getattr(expr, "checked", None) is not None else False, + } + for expr in style_query + ] + + # 要求至少有一定数量的 count > 1 的表达方式才进行“完整简单模式”选择 + min_required = 8 + if len(style_exprs) < min_required: + # 高 count 样本不足：如果还有候选，就降级为随机选 3 个；如果一个都没有，则直接返回空 + if not style_exprs: + logger.info( + f"聊天流 {chat_id} 没有满足 count > 1 且未被拒绝的表达方式，简单模式不进行选择" + ) + # 完全没有高 count 样本时，退化为全量随机抽样（不进入LLM流程） + fallback_num = min(3, max_num) if max_num > 0 else 3 + fallback_selected = self._random_expressions(chat_id, fallback_num) + if fallback_selected: + self.update_expressions_last_active_time(fallback_selected) + selected_ids = [expr["id"] for expr in fallback_selected] + logger.info( + f"聊天流 {chat_id} 使用简单模式降级随机抽选 {len(fallback_selected)} 个表达（无 count>1 样本）" + ) + return fallback_selected, selected_ids + return [], [] + logger.info( + f"聊天流 {chat_id} count > 1 的表达方式不足 {min_required} 个（实际 {len(style_exprs)} 个），" + f"简单模式降级为随机选择 3 个" + ) + select_count = min(3, len(style_exprs)) + else: + # 高 count 数量达标时，固定选择 5 个 + select_count = 5 + import random + + selected_style = random.sample(style_exprs, select_count) + + # 更新last_active_time + if selected_style: + self.update_expressions_last_active_time(selected_style) + + selected_ids = [expr["id"] for expr in selected_style] + logger.debug( + f"think_level=0: 从 {len(style_exprs)} 个 count>1 的表达方式中随机选择了 {len(selected_style)} 个" + ) + return selected_style, selected_ids + + except Exception as e: + logger.error(f"简单模式选择表达方式失败: {e}") + return [], [] + def _random_expressions(self, chat_id: str, total_num: int) -> List[Dict[str, Any]]: """ 随机选择表达方式 @@ -126,8 +201,8 @@ class ExpressionSelector: # 支持多chat_id合并抽选 related_chat_ids = self.get_related_chat_ids(chat_id) - # 优化：一次性查询所有相关chat_id的表达方式 - style_query = Expression.select().where((Expression.chat_id.in_(related_chat_ids))) + # 优化：一次性查询所有相关chat_id的表达方式，排除 rejected=1 的表达 + style_query = Expression.select().where((Expression.chat_id.in_(related_chat_ids)) & (~Expression.rejected)) style_exprs = [ { @@ -138,6 +213,7 @@ class ExpressionSelector: "source_id": expr.chat_id, "create_date": expr.create_date if expr.create_date is not None else expr.last_active_time, "count": expr.count if getattr(expr, "count", None) is not None else 1, + "checked": expr.checked if getattr(expr, "checked", None) is not None else False, } for expr in style_query ] @@ -148,7 +224,6 @@ class ExpressionSelector: else: selected_style = [] - logger.info(f"随机选择，为聊天室 {chat_id} 选择了 {len(selected_style)} 个表达方式") return selected_style except Exception as e: @@ -162,6 +237,7 @@ class ExpressionSelector: max_num: int = 10, target_message: Optional[str] = None, reply_reason: Optional[str] = None, + think_level: int = 1, ) -> Tuple[List[Dict[str, Any]], List[int]]: """ 选择适合的表达方式（使用classic模式：随机选择+LLM选择） @@ -172,6 +248,7 @@ class ExpressionSelector: max_num: 最大选择数量 target_message: 目标消息内容 reply_reason: planner给出的回复理由 + think_level: 思考级别，0/1 Returns: Tuple[List[Dict[str, Any]], List[int]]: 选中的表达方式列表和ID列表 @@ -182,8 +259,10 @@ class ExpressionSelector: return [], [] # 使用classic模式（随机选择+LLM选择） - logger.debug(f"使用classic模式为聊天流 {chat_id} 选择表达方式") - return await self._select_expressions_classic(chat_id, chat_info, max_num, target_message, reply_reason) + logger.debug(f"使用classic模式为聊天流 {chat_id} 选择表达方式，think_level={think_level}") + return await self._select_expressions_classic( + chat_id, chat_info, max_num, target_message, reply_reason, think_level + ) async def _select_expressions_classic( self, @@ -192,6 +271,7 @@ class ExpressionSelector: max_num: int = 10, target_message: Optional[str] = None, reply_reason: Optional[str] = None, + think_level: int = 1, ) -> Tuple[List[Dict[str, Any]], List[int]]: """ classic模式：随机选择+LLM选择 @@ -202,24 +282,91 @@ class ExpressionSelector: max_num: 最大选择数量 target_message: 目标消息内容 reply_reason: planner给出的回复理由 + think_level: 思考级别，0/1 Returns: Tuple[List[Dict[str, Any]], List[int]]: 选中的表达方式列表和ID列表 """ try: - # 1. 使用随机抽样选择表达方式 - style_exprs = self._random_expressions(chat_id, 20) + # think_level == 0: 只选择 count > 1 的项目，随机选10个，不进行LLM选择 + if think_level == 0: + return self._select_expressions_simple(chat_id, max_num) - if len(style_exprs) < 10: - logger.info(f"聊天流 {chat_id} 表达方式正在积累中") + # think_level == 1: 先选高count，再从所有表达方式中随机抽样 + # 1. 获取所有表达方式并分离 count > 1 和 count <= 1 的 + related_chat_ids = self.get_related_chat_ids(chat_id) + style_query = Expression.select().where((Expression.chat_id.in_(related_chat_ids)) & (~Expression.rejected)) + + all_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, + "count": expr.count if getattr(expr, "count", None) is not None else 1, + "checked": expr.checked if getattr(expr, "checked", None) is not None else False, + } + for expr in style_query + ] + + # 分离 count > 1 和 count <= 1 的表达方式 + high_count_exprs = [expr for expr in all_style_exprs if (expr.get("count", 1) or 1) > 1] + + # 根据 think_level 设置要求（仅支持 0/1，0 已在上方返回） + min_high_count = 10 + min_total_count = 10 + select_high_count = 5 + select_random_count = 5 + + # 检查数量要求 + # 对于高 count 表达：如果数量不足，不再直接停止，而是仅跳过“高 count 优先选择” + if len(high_count_exprs) < min_high_count: + logger.info( + f"聊天流 {chat_id} count > 1 的表达方式不足 {min_high_count} 个（实际 {len(high_count_exprs)} 个），" + f"将跳过高 count 优先选择，仅从全部表达中随机抽样" + ) + high_count_valid = False + else: + high_count_valid = True + + # 总量不足仍然直接返回，避免样本过少导致选择质量过低 + if len(all_style_exprs) < min_total_count: + logger.info( + f"聊天流 {chat_id} 总表达方式不足 {min_total_count} 个（实际 {len(all_style_exprs)} 个），不进行选择" + ) return [], [] + # 先选取高count的表达方式（如果数量达标） + if high_count_valid: + selected_high = weighted_sample(high_count_exprs, min(len(high_count_exprs), select_high_count)) + else: + selected_high = [] + + # 然后从所有表达方式中随机抽样（使用加权抽样） + remaining_num = select_random_count + selected_random = weighted_sample(all_style_exprs, min(len(all_style_exprs), remaining_num)) + + # 合并候选池（去重，避免重复） + candidate_exprs = selected_high.copy() + candidate_ids = {expr["id"] for expr in candidate_exprs} + for expr in selected_random: + if expr["id"] not in candidate_ids: + candidate_exprs.append(expr) + candidate_ids.add(expr["id"]) + + # 打乱顺序，避免高count的都在前面 + import random + + random.shuffle(candidate_exprs) + # 2. 构建所有表达方式的索引和情境列表 all_expressions: List[Dict[str, Any]] = [] all_situations: List[str] = [] # 添加style表达方式 - for expr in style_exprs: + for expr in candidate_exprs: expr = expr.copy() all_expressions.append(expr) all_situations.append(f"{len(all_expressions)}.当 {expr['situation']} 时，使用 {expr['style']}") @@ -231,7 +378,7 @@ class ExpressionSelector: all_situations_str = "\n".join(all_situations) if target_message: - target_message_str = f"，现在你想要对这条消息进行回复：“{target_message}”" + target_message_str = f'，现在你想要对这条消息进行回复："{target_message}"' target_message_extra_block = "4.考虑你要回复的目标消息" else: target_message_str = "" @@ -260,7 +407,8 @@ class ExpressionSelector: # 4. 调用LLM content, (reasoning_content, model_name, _) = await self.llm_model.generate_response_async(prompt=prompt) - # print(prompt) + print(prompt) + print(content) if not content: logger.warning("LLM返回空结果") @@ -291,7 +439,7 @@ class ExpressionSelector: if valid_expressions: self.update_expressions_last_active_time(valid_expressions) - logger.info(f"classic模式从{len(all_expressions)}个情境中选择了{len(valid_expressions)}个") + logger.debug(f"从{len(all_expressions)}个情境中选择了{len(valid_expressions)}个") return valid_expressions, selected_ids except Exception as e: diff --git a/src/bw_learner/jargon_explainer.py b/src/bw_learner/jargon_explainer.py new file mode 100644 index 00000000..207a080a --- /dev/null +++ b/src/bw_learner/jargon_explainer.py @@ -0,0 +1,365 @@ +import re +import time +from typing import List, Dict, Optional, Any + +from src.common.logger import get_logger +from src.common.database.database_model import Jargon +from src.llm_models.utils_model import LLMRequest +from src.config.config import model_config, global_config +from src.chat.utils.prompt_builder import Prompt, global_prompt_manager +from src.bw_learner.jargon_miner import search_jargon +from src.bw_learner.learner_utils import ( + is_bot_message, + contains_bot_self_name, + parse_chat_id_list, + chat_id_list_contains, +) + +logger = get_logger("jargon") + + +def _init_explainer_prompts() -> None: + """初始化黑话解释器相关的prompt""" + # Prompt：概括黑话解释结果 + summarize_prompt_str = """上下文聊天内容: +{chat_context} + +在上下文中提取到的黑话及其含义: +{jargon_explanations} + +请根据上述信息，对黑话解释进行概括和整理。 +- 如果上下文中有黑话出现，请简要说明这些黑话在上下文中的使用情况 +- 将所有黑话解释整理成简洁、易读的一段话 +- 输出格式要自然，适合作为回复参考信息 +请输出概括后的黑话解释（直接输出一段平文本，不要标题，无特殊格式或markdown格式，不要使用JSON格式）： +""" + Prompt(summarize_prompt_str, "jargon_explainer_summarize_prompt") + + +_init_explainer_prompts() + + +class JargonExplainer: + """黑话解释器，用于在回复前识别和解释上下文中的黑话""" + + def __init__(self, chat_id: str) -> None: + self.chat_id = chat_id + self.llm = LLMRequest( + model_set=model_config.model_task_config.utils, + request_type="jargon.explain", + ) + + def match_jargon_from_messages(self, messages: List[Any]) -> List[Dict[str, str]]: + """ + 通过直接匹配数据库中的jargon字符串来提取黑话 + + Args: + messages: 消息列表 + + Returns: + List[Dict[str, str]]: 提取到的黑话列表，每个元素包含content + """ + start_time = time.time() + + if not messages: + return [] + + # 收集所有消息的文本内容 + message_texts: List[str] = [] + for msg in messages: + # 跳过机器人自己的消息 + if is_bot_message(msg): + continue + + msg_text = ( + getattr(msg, "display_message", None) or getattr(msg, "processed_plain_text", None) or "" + ).strip() + if msg_text: + message_texts.append(msg_text) + + if not message_texts: + return [] + + # 合并所有消息文本 + combined_text = " ".join(message_texts) + + # 查询所有有meaning的jargon记录 + query = Jargon.select().where((Jargon.meaning.is_null(False)) & (Jargon.meaning != "")) + + # 根据all_global配置决定查询逻辑 + if global_config.expression.all_global_jargon: + # 开启all_global：只查询is_global=True的记录 + query = query.where(Jargon.is_global) + else: + # 关闭all_global：查询is_global=True或chat_id列表包含当前chat_id的记录 + # 这里先查询所有，然后在Python层面过滤 + pass + + # 按count降序排序，优先匹配出现频率高的 + query = query.order_by(Jargon.count.desc()) + + # 执行查询并匹配 + matched_jargon: Dict[str, Dict[str, str]] = {} + query_time = time.time() + + for jargon in query: + content = jargon.content or "" + if not content or not content.strip(): + continue + + # 跳过包含机器人昵称的词条 + if contains_bot_self_name(content): + continue + + # 检查chat_id（如果all_global=False） + if not global_config.expression.all_global_jargon: + if jargon.is_global: + # 全局黑话，包含 + pass + else: + # 检查chat_id列表是否包含当前chat_id + chat_id_list = parse_chat_id_list(jargon.chat_id) + if not chat_id_list_contains(chat_id_list, self.chat_id): + continue + + # 在文本中查找匹配（大小写不敏感） + pattern = re.escape(content) + # 使用单词边界或中文字符边界来匹配，避免部分匹配 + # 对于中文，使用Unicode字符类；对于英文，使用单词边界 + if re.search(r"[\u4e00-\u9fff]", content): + # 包含中文，使用更宽松的匹配 + search_pattern = pattern + else: + # 纯英文/数字，使用单词边界 + search_pattern = r"\b" + pattern + r"\b" + + if re.search(search_pattern, combined_text, re.IGNORECASE): + # 找到匹配，记录（去重） + if content not in matched_jargon: + matched_jargon[content] = {"content": content} + + match_time = time.time() + total_time = match_time - start_time + query_duration = query_time - start_time + match_duration = match_time - query_time + + logger.debug( + f"黑话匹配完成: 查询耗时 {query_duration:.3f}s, 匹配耗时 {match_duration:.3f}s, " + f"总耗时 {total_time:.3f}s, 匹配到 {len(matched_jargon)} 个黑话" + ) + + return list(matched_jargon.values()) + + async def explain_jargon(self, messages: List[Any], chat_context: str) -> Optional[str]: + """ + 解释上下文中的黑话 + + Args: + messages: 消息列表 + chat_context: 聊天上下文的文本表示 + + Returns: + Optional[str]: 黑话解释的概括文本，如果没有黑话则返回None + """ + if not messages: + return None + + # 直接匹配方式：从数据库中查询jargon并在消息中匹配 + jargon_entries = self.match_jargon_from_messages(messages) + + if not jargon_entries: + return None + + # 去重（按content） + unique_jargon: Dict[str, Dict[str, str]] = {} + for entry in jargon_entries: + content = entry["content"] + if content not in unique_jargon: + unique_jargon[content] = entry + + jargon_list = list(unique_jargon.values()) + logger.info(f"从上下文中提取到 {len(jargon_list)} 个黑话: {[j['content'] for j in jargon_list]}") + + # 查询每个黑话的含义 + jargon_explanations: List[str] = [] + for entry in jargon_list: + content = entry["content"] + + # 根据是否开启全局黑话，决定查询方式 + if global_config.expression.all_global_jargon: + # 开启全局黑话：查询所有is_global=True的记录 + results = search_jargon( + keyword=content, + chat_id=None, # 不指定chat_id，查询全局黑话 + limit=1, + case_sensitive=False, + fuzzy=False, # 精确匹配 + ) + else: + # 关闭全局黑话：优先查询当前聊天或全局的黑话 + results = search_jargon( + keyword=content, + chat_id=self.chat_id, + limit=1, + case_sensitive=False, + fuzzy=False, # 精确匹配 + ) + + if results and len(results) > 0: + meaning = results[0].get("meaning", "").strip() + if meaning: + jargon_explanations.append(f"- {content}: {meaning}") + else: + logger.info(f"黑话 {content} 没有找到含义") + else: + logger.info(f"黑话 {content} 未在数据库中找到") + + if not jargon_explanations: + logger.info("没有找到任何黑话的含义，跳过解释") + return None + + # 拼接所有黑话解释 + explanations_text = "\n".join(jargon_explanations) + + # 使用LLM概括黑话解释 + summarize_prompt = await global_prompt_manager.format_prompt( + "jargon_explainer_summarize_prompt", + chat_context=chat_context, + jargon_explanations=explanations_text, + ) + + summary, _ = await self.llm.generate_response_async(summarize_prompt, temperature=0.3) + if not summary: + # 如果LLM概括失败，直接返回原始解释 + return f"上下文中的黑话解释：\n{explanations_text}" + + summary = summary.strip() + if not summary: + return f"上下文中的黑话解释：\n{explanations_text}" + + return summary + + +async def explain_jargon_in_context(chat_id: str, messages: List[Any], chat_context: str) -> Optional[str]: + """ + 解释上下文中的黑话（便捷函数） + + Args: + chat_id: 聊天ID + messages: 消息列表 + chat_context: 聊天上下文的文本表示 + + Returns: + Optional[str]: 黑话解释的概括文本，如果没有黑话则返回None + """ + explainer = JargonExplainer(chat_id) + return await explainer.explain_jargon(messages, chat_context) + + +def match_jargon_from_text(chat_text: str, chat_id: str) -> List[str]: + """直接在聊天文本中匹配已知的jargon，返回出现过的黑话列表 + + Args: + chat_text: 要匹配的聊天文本 + chat_id: 聊天ID + + Returns: + List[str]: 匹配到的黑话列表 + """ + if not chat_text or not chat_text.strip(): + return [] + + query = Jargon.select().where((Jargon.meaning.is_null(False)) & (Jargon.meaning != "")) + if global_config.expression.all_global_jargon: + query = query.where(Jargon.is_global) + + query = query.order_by(Jargon.count.desc()) + + matched: Dict[str, None] = {} + + for jargon in query: + content = (jargon.content or "").strip() + if not content: + continue + + if not global_config.expression.all_global_jargon and not jargon.is_global: + chat_id_list = parse_chat_id_list(jargon.chat_id) + if not chat_id_list_contains(chat_id_list, chat_id): + continue + + pattern = re.escape(content) + if re.search(r"[\u4e00-\u9fff]", content): + search_pattern = pattern + else: + search_pattern = r"\b" + pattern + r"\b" + + if re.search(search_pattern, chat_text, re.IGNORECASE): + matched[content] = None + + logger.info(f"匹配到 {len(matched)} 个黑话") + + return list(matched.keys()) + + +async def retrieve_concepts_with_jargon(concepts: List[str], chat_id: str) -> str: + """对概念列表进行jargon检索 + + Args: + concepts: 概念列表 + chat_id: 聊天ID + + Returns: + str: 检索结果字符串 + """ + if not concepts: + return "" + + results = [] + exact_matches = [] # 收集所有精确匹配的概念 + for concept in concepts: + concept = concept.strip() + if not concept: + continue + + # 先尝试精确匹配 + jargon_results = search_jargon(keyword=concept, chat_id=chat_id, limit=10, case_sensitive=False, fuzzy=False) + + is_fuzzy_match = False + + # 如果精确匹配未找到，尝试模糊搜索 + if not jargon_results: + jargon_results = search_jargon(keyword=concept, chat_id=chat_id, limit=10, case_sensitive=False, fuzzy=True) + is_fuzzy_match = True + + if jargon_results: + # 找到结果 + if is_fuzzy_match: + # 模糊匹配 + output_parts = [f"未精确匹配到'{concept}'"] + for result in jargon_results: + found_content = result.get("content", "").strip() + meaning = result.get("meaning", "").strip() + if found_content and meaning: + output_parts.append(f"找到 '{found_content}' 的含义为：{meaning}") + results.append("，".join(output_parts)) + logger.info(f"在jargon库中找到匹配（模糊搜索）: {concept}，找到{len(jargon_results)}条结果") + else: + # 精确匹配 + output_parts = [] + for result in jargon_results: + meaning = result.get("meaning", "").strip() + if meaning: + output_parts.append(f"'{concept}' 为黑话或者网络简写，含义为：{meaning}") + results.append("；".join(output_parts) if len(output_parts) > 1 else output_parts[0]) + exact_matches.append(concept) # 收集精确匹配的概念，稍后统一打印 + else: + # 未找到，不返回占位信息，只记录日志 + logger.info(f"在jargon库中未找到匹配: {concept}") + + # 合并所有精确匹配的日志 + if exact_matches: + logger.info(f"找到黑话: {', '.join(exact_matches)}，共找到{len(exact_matches)}条结果") + + if results: + return "【概念检索结果】\n" + "\n".join(results) + "\n" + return "" diff --git a/src/bw_learner/jargon_miner.py b/src/bw_learner/jargon_miner.py new file mode 100644 index 00000000..f1580fc4 --- /dev/null +++ b/src/bw_learner/jargon_miner.py @@ -0,0 +1,986 @@ +import json +import asyncio +import random +from collections import OrderedDict +from typing import List, Dict, Optional, Any, Callable +from json_repair import repair_json +from peewee import fn + +from src.common.logger import get_logger +from src.common.database.database_model import Jargon +from src.llm_models.utils_model import LLMRequest +from src.config.config import model_config, global_config +from src.chat.message_receive.chat_stream import get_chat_manager +from src.chat.utils.chat_message_builder import ( + build_readable_messages_with_id, +) +from src.chat.utils.prompt_builder import Prompt, global_prompt_manager +from src.bw_learner.learner_utils import ( + is_bot_message, + build_context_paragraph, + contains_bot_self_name, + parse_chat_id_list, + chat_id_list_contains, + update_chat_id_list, +) + + +logger = get_logger("jargon") + + +def _is_single_char_jargon(content: str) -> bool: + """ + 判断是否是单字黑话（单个汉字、英文或数字） + + Args: + content: 词条内容 + + Returns: + bool: 如果是单字黑话返回True，否则返回False + """ + if not content or len(content) != 1: + return False + + char = content[0] + # 判断是否是单个汉字、单个英文字母或单个数字 + return ( + "\u4e00" <= char <= "\u9fff" # 汉字 + or "a" <= char <= "z" # 小写字母 + or "A" <= char <= "Z" # 大写字母 + or "0" <= char <= "9" # 数字 + ) + + +def _init_prompt() -> None: + prompt_str = """ +**聊天内容，其中的{bot_name}的发言内容是你自己的发言，[msg_id] 是消息ID** +{chat_str} + +请从上面这段聊天内容中提取"可能是黑话"的候选项（黑话/俚语/网络缩写/口头禅）。 +- 必须为对话中真实出现过的短词或短语 +- 必须是你无法理解含义的词语，没有明确含义的词语，请不要选择有明确含义，或者含义清晰的词语 +- 排除：人名、@、表情包/图片中的内容、纯标点、常规功能词（如的、了、呢、啊等） +- 每个词条长度建议 2-8 个字符（不强制），尽量短小 + +黑话必须为以下几种类型： +- 由字母构成的，汉语拼音首字母的简写词，例如：nb、yyds、xswl +- 英文词语的缩写，用英文字母概括一个词汇或含义，例如：CPU、GPU、API +- 中文词语的缩写，用几个汉字概括一个词汇或含义，例如：社死、内卷 + +以 JSON 数组输出，元素为对象（严格按以下结构）： +请你提取出可能的黑话，最多30个黑话，请尽量提取所有 +[ + {{"content": "词条", "msg_id": "m12"}}, // msg_id 必须与上方聊天中展示的ID完全一致 + {{"content": "词条2", "msg_id": "m15"}} +] + +现在请输出： +""" + Prompt(prompt_str, "extract_jargon_prompt") + + +def _init_inference_prompts() -> None: + """初始化含义推断相关的prompt""" + # Prompt 1: 基于raw_content和content推断 + prompt1_str = """ +**词条内容** +{content} +**词条出现的上下文。其中的{bot_name}的发言内容是你自己的发言** +{raw_content_list} +{previous_meaning_section} + +请根据上下文，推断"{content}"这个词条的含义。 +- 如果这是一个黑话、俚语或网络用语，请推断其含义 +- 如果含义明确（常规词汇），也请说明 +- {bot_name} 的发言内容可能包含错误，请不要参考其发言内容 +- 如果上下文信息不足，无法推断含义，请设置 no_info 为 true +{previous_meaning_instruction} + +以 JSON 格式输出： +{{ + "meaning": "详细含义说明（包含使用场景、来源、具体解释等）", + "no_info": false +}} +注意：如果信息不足无法推断，请设置 "no_info": true，此时 meaning 可以为空字符串 +""" + Prompt(prompt1_str, "jargon_inference_with_context_prompt") + + # Prompt 2: 仅基于content推断 + prompt2_str = """ +**词条内容** +{content} + +请仅根据这个词条本身，推断其含义。 +- 如果这是一个黑话、俚语或网络用语，请推断其含义 +- 如果含义明确（常规词汇），也请说明 + +以 JSON 格式输出： +{{ + "meaning": "详细含义说明（包含使用场景、来源、具体解释等）" +}} +""" + Prompt(prompt2_str, "jargon_inference_content_only_prompt") + + # Prompt 3: 比较两个推断结果 + prompt3_str = """ +**推断结果1（基于上下文）** +{inference1} + +**推断结果2（仅基于词条）** +{inference2} + +请比较这两个推断结果，判断它们是否相同或类似。 +- 如果两个推断结果的"含义"相同或类似，说明这个词条不是黑话（含义明确） +- 如果两个推断结果有差异，说明这个词条可能是黑话（需要上下文才能理解） + +以 JSON 格式输出： +{{ + "is_similar": true/false, + "reason": "判断理由" +}} +""" + Prompt(prompt3_str, "jargon_compare_inference_prompt") + + +_init_prompt() +_init_inference_prompts() + + +def _should_infer_meaning(jargon_obj: Jargon) -> bool: + """ + 判断是否需要进行含义推断 + 在 count 达到 3,6, 10, 20, 40, 60, 100 时进行推断 + 并且count必须大于last_inference_count，避免重启后重复判定 + 如果is_complete为True，不再进行推断 + """ + # 如果已完成所有推断，不再推断 + if jargon_obj.is_complete: + return False + + count = jargon_obj.count or 0 + last_inference = jargon_obj.last_inference_count or 0 + + # 阈值列表：3,6, 10, 20, 40, 60, 100 + thresholds = [2, 4, 8, 12, 24, 60, 100] + + if count < thresholds[0]: + return False + + # 如果count没有超过上次判定值，不需要判定 + if count <= last_inference: + return False + + # 找到第一个大于last_inference的阈值 + next_threshold = None + for threshold in thresholds: + if threshold > last_inference: + next_threshold = threshold + break + + # 如果没有找到下一个阈值，说明已经超过100，不应该再推断 + if next_threshold is None: + return False + + # 检查count是否达到或超过这个阈值 + return count >= next_threshold + + +class JargonMiner: + def __init__(self, chat_id: str) -> None: + self.chat_id = chat_id + + self.llm = LLMRequest( + model_set=model_config.model_task_config.utils, + request_type="jargon.extract", + ) + + self.llm_inference = LLMRequest( + model_set=model_config.model_task_config.utils, + request_type="jargon.inference", + ) + + # 初始化stream_name作为类属性，避免重复提取 + chat_manager = get_chat_manager() + stream_name = chat_manager.get_stream_name(self.chat_id) + self.stream_name = stream_name if stream_name else self.chat_id + self.cache_limit = 50 + self.cache: OrderedDict[str, None] = OrderedDict() + + # 黑话提取锁，防止并发执行 + self._extraction_lock = asyncio.Lock() + + def _add_to_cache(self, content: str) -> None: + """将提取到的黑话加入缓存，保持LRU语义""" + if not content: + return + + key = content.strip() + if not key: + return + + # 单字黑话（单个汉字、英文或数字）不记录到缓存 + if _is_single_char_jargon(key): + return + + if key in self.cache: + self.cache.move_to_end(key) + else: + self.cache[key] = None + if len(self.cache) > self.cache_limit: + self.cache.popitem(last=False) + + def _collect_cached_entries(self, messages: List[Any]) -> List[Dict[str, List[str]]]: + """检查缓存中的黑话是否出现在当前消息窗口，生成对应上下文""" + if not self.cache or not messages: + return [] + + cached_entries: List[Dict[str, List[str]]] = [] + processed_pairs = set() + + for idx, msg in enumerate(messages): + msg_text = ( + getattr(msg, "display_message", None) or getattr(msg, "processed_plain_text", None) or "" + ).strip() + if not msg_text or is_bot_message(msg): + continue + + for content in self.cache.keys(): + if not content: + continue + if (content, idx) in processed_pairs: + continue + if content in msg_text: + paragraph = build_context_paragraph(messages, idx) + if not paragraph: + continue + cached_entries.append({"content": content, "raw_content": [paragraph]}) + processed_pairs.add((content, idx)) + + return cached_entries + + async def _infer_meaning_by_id(self, jargon_id: int) -> None: + """通过ID加载对象并推断""" + try: + jargon_obj = Jargon.get_by_id(jargon_id) + # 再次检查is_complete，因为可能在异步任务执行时已被标记为完成 + if jargon_obj.is_complete: + logger.debug(f"jargon {jargon_obj.content} 已完成所有推断，跳过") + return + await self.infer_meaning(jargon_obj) + except Exception as e: + logger.error(f"通过ID推断jargon失败: {e}") + + async def infer_meaning(self, jargon_obj: Jargon) -> None: + """ + 对jargon进行含义推断 + """ + try: + content = jargon_obj.content + raw_content_str = jargon_obj.raw_content or "" + + # 解析raw_content列表 + raw_content_list = [] + if raw_content_str: + try: + raw_content_list = ( + json.loads(raw_content_str) if isinstance(raw_content_str, str) else raw_content_str + ) + if not isinstance(raw_content_list, list): + raw_content_list = [raw_content_list] if raw_content_list else [] + except (json.JSONDecodeError, TypeError): + raw_content_list = [raw_content_str] if raw_content_str else [] + + if not raw_content_list: + logger.warning(f"jargon {content} 没有raw_content，跳过推断") + return + + # 获取当前count和上一次的meaning + current_count = jargon_obj.count or 0 + previous_meaning = jargon_obj.meaning or "" + + # 当count为24, 60时，随机移除一半的raw_content项目 + if current_count in [24, 60] and len(raw_content_list) > 1: + # 计算要保留的数量（至少保留1个） + keep_count = max(1, len(raw_content_list) // 2) + raw_content_list = random.sample(raw_content_list, keep_count) + logger.info( + f"jargon {content} count={current_count}，随机移除后剩余 {len(raw_content_list)} 个raw_content项目" + ) + + # 步骤1: 基于raw_content和content推断 + raw_content_text = "\n".join(raw_content_list) + + # 当count为24, 60, 100时，在prompt中放入上一次推断出的meaning作为参考 + previous_meaning_section = "" + previous_meaning_instruction = "" + if current_count in [24, 60, 100] and previous_meaning: + previous_meaning_section = f""" +**上一次推断的含义（仅供参考）** +{previous_meaning} +""" + previous_meaning_instruction = ( + "- 请参考上一次推断的含义，结合新的上下文信息，给出更准确或更新的推断结果" + ) + + prompt1 = await global_prompt_manager.format_prompt( + "jargon_inference_with_context_prompt", + content=content, + bot_name=global_config.bot.nickname, + raw_content_list=raw_content_text, + previous_meaning_section=previous_meaning_section, + previous_meaning_instruction=previous_meaning_instruction, + ) + + response1, _ = await self.llm_inference.generate_response_async(prompt1, temperature=0.3) + if not response1: + logger.warning(f"jargon {content} 推断1失败：无响应") + return + + # 解析推断1结果 + inference1 = None + try: + resp1 = response1.strip() + if resp1.startswith("{") and resp1.endswith("}"): + inference1 = json.loads(resp1) + else: + repaired = repair_json(resp1) + inference1 = json.loads(repaired) if isinstance(repaired, str) else repaired + if not isinstance(inference1, dict): + logger.warning(f"jargon {content} 推断1结果格式错误") + return + except Exception as e: + logger.error(f"jargon {content} 推断1解析失败: {e}") + return + + # 检查推断1是否表示信息不足无法推断 + no_info = inference1.get("no_info", False) + meaning1 = inference1.get("meaning", "").strip() + if no_info or not meaning1: + logger.info(f"jargon {content} 推断1表示信息不足无法推断，放弃本次推断，待下次更新") + # 更新最后一次判定的count值，避免在同一阈值重复尝试 + jargon_obj.last_inference_count = jargon_obj.count or 0 + jargon_obj.save() + return + + # 步骤2: 仅基于content推断 + prompt2 = await global_prompt_manager.format_prompt( + "jargon_inference_content_only_prompt", + content=content, + ) + + response2, _ = await self.llm_inference.generate_response_async(prompt2, temperature=0.3) + if not response2: + logger.warning(f"jargon {content} 推断2失败：无响应") + return + + # 解析推断2结果 + inference2 = None + try: + resp2 = response2.strip() + if resp2.startswith("{") and resp2.endswith("}"): + inference2 = json.loads(resp2) + else: + repaired = repair_json(resp2) + inference2 = json.loads(repaired) if isinstance(repaired, str) else repaired + if not isinstance(inference2, dict): + logger.warning(f"jargon {content} 推断2结果格式错误") + return + except Exception as e: + logger.error(f"jargon {content} 推断2解析失败: {e}") + return + + # logger.info(f"jargon {content} 推断2提示词: {prompt2}") + # logger.info(f"jargon {content} 推断2结果: {response2}") + # logger.info(f"jargon {content} 推断1提示词: {prompt1}") + # logger.info(f"jargon {content} 推断1结果: {response1}") + + if global_config.debug.show_jargon_prompt: + logger.info(f"jargon {content} 推断2提示词: {prompt2}") + logger.info(f"jargon {content} 推断2结果: {response2}") + logger.info(f"jargon {content} 推断1提示词: {prompt1}") + logger.info(f"jargon {content} 推断1结果: {response1}") + else: + logger.debug(f"jargon {content} 推断2提示词: {prompt2}") + logger.debug(f"jargon {content} 推断2结果: {response2}") + logger.debug(f"jargon {content} 推断1提示词: {prompt1}") + logger.debug(f"jargon {content} 推断1结果: {response1}") + + # 步骤3: 比较两个推断结果 + prompt3 = await global_prompt_manager.format_prompt( + "jargon_compare_inference_prompt", + inference1=json.dumps(inference1, ensure_ascii=False), + inference2=json.dumps(inference2, ensure_ascii=False), + ) + + if global_config.debug.show_jargon_prompt: + logger.info(f"jargon {content} 比较提示词: {prompt3}") + + response3, _ = await self.llm_inference.generate_response_async(prompt3, temperature=0.3) + if not response3: + logger.warning(f"jargon {content} 比较失败：无响应") + return + + # 解析比较结果 + comparison = None + try: + resp3 = response3.strip() + if resp3.startswith("{") and resp3.endswith("}"): + comparison = json.loads(resp3) + else: + repaired = repair_json(resp3) + comparison = json.loads(repaired) if isinstance(repaired, str) else repaired + if not isinstance(comparison, dict): + logger.warning(f"jargon {content} 比较结果格式错误") + return + except Exception as e: + logger.error(f"jargon {content} 比较解析失败: {e}") + return + + # 判断是否为黑话 + is_similar = comparison.get("is_similar", False) + is_jargon = not is_similar # 如果相似，说明不是黑话；如果有差异，说明是黑话 + + # 更新数据库记录 + jargon_obj.is_jargon = is_jargon + if is_jargon: + # 是黑话，使用推断1的结果（基于上下文，更准确） + jargon_obj.meaning = inference1.get("meaning", "") + else: + # 不是黑话，清空含义，不再存储任何内容 + jargon_obj.meaning = "" + + # 更新最后一次判定的count值，避免重启后重复判定 + jargon_obj.last_inference_count = jargon_obj.count or 0 + + # 如果count>=100，标记为完成，不再进行推断 + if (jargon_obj.count or 0) >= 100: + jargon_obj.is_complete = True + + jargon_obj.save() + logger.debug( + f"jargon {content} 推断完成: is_jargon={is_jargon}, meaning={jargon_obj.meaning}, last_inference_count={jargon_obj.last_inference_count}, is_complete={jargon_obj.is_complete}" + ) + + # 固定输出推断结果，格式化为可读形式 + if is_jargon: + # 是黑话，输出格式：[聊天名]xxx的含义是 xxxxxxxxxxx + meaning = jargon_obj.meaning or "无详细说明" + is_global = jargon_obj.is_global + if is_global: + logger.info(f"[黑话]{content}的含义是 {meaning}") + else: + logger.info(f"[{self.stream_name}]{content}的含义是 {meaning}") + else: + # 不是黑话，输出格式：[聊天名]xxx 不是黑话 + logger.info(f"[{self.stream_name}]{content} 不是黑话") + + except Exception as e: + logger.error(f"jargon推断失败: {e}") + import traceback + + traceback.print_exc() + + async def run_once( + self, + messages: List[Any], + person_name_filter: Optional[Callable[[str], bool]] = None + ) -> None: + """ + 运行一次黑话提取 + + Args: + messages: 外部传入的消息列表（必需） + person_name_filter: 可选的过滤函数，用于检查内容是否包含人物名称 + """ + # 使用异步锁防止并发执行 + async with self._extraction_lock: + try: + if not messages: + return + + # 按时间排序，确保编号与上下文一致 + messages = sorted(messages, key=lambda msg: msg.time or 0) + + chat_str, message_id_list = build_readable_messages_with_id( + messages=messages, + replace_bot_name=True, + timestamp_mode="relative", + truncate=False, + show_actions=False, + show_pic=True, + pic_single=True, + ) + if not chat_str.strip(): + return + + msg_id_to_index: Dict[str, int] = {} + for idx, (msg_id, _msg) in enumerate(message_id_list or []): + if not msg_id: + continue + msg_id_to_index[msg_id] = idx + if not msg_id_to_index: + logger.warning("未能生成消息ID映射，跳过本次提取") + return + + prompt: str = await global_prompt_manager.format_prompt( + "extract_jargon_prompt", + bot_name=global_config.bot.nickname, + chat_str=chat_str, + ) + + response, _ = await self.llm.generate_response_async(prompt, temperature=0.2) + if not response: + return + + if global_config.debug.show_jargon_prompt: + logger.info(f"jargon提取提示词: {prompt}") + logger.info(f"jargon提取结果: {response}") + + # 解析为JSON + entries: List[dict] = [] + try: + resp = response.strip() + parsed = None + if resp.startswith("[") and resp.endswith("]"): + parsed = json.loads(resp) + else: + repaired = repair_json(resp) + if isinstance(repaired, str): + parsed = json.loads(repaired) + else: + parsed = repaired + + if isinstance(parsed, dict): + parsed = [parsed] + + if not isinstance(parsed, list): + return + + for item in parsed: + if not isinstance(item, dict): + continue + + content = str(item.get("content", "")).strip() + msg_id_value = item.get("msg_id") + + if not content: + continue + + if contains_bot_self_name(content): + logger.info(f"解析阶段跳过包含机器人昵称/别名的词条: {content}") + continue + + # 检查是否包含人物名称 + if person_name_filter and person_name_filter(content): + logger.info(f"解析阶段跳过包含人物名称的词条: {content}") + continue + + msg_id_str = str(msg_id_value or "").strip() + if not msg_id_str: + logger.warning(f"解析jargon失败：msg_id缺失，content={content}") + continue + + msg_index = msg_id_to_index.get(msg_id_str) + if msg_index is None: + logger.warning(f"解析jargon失败：msg_id未找到，content={content}, msg_id={msg_id_str}") + continue + + target_msg = messages[msg_index] + if is_bot_message(target_msg): + logger.info(f"解析阶段跳过引用机器人自身消息的词条: content={content}, msg_id={msg_id_str}") + continue + + context_paragraph = build_context_paragraph(messages, msg_index) + if not context_paragraph: + logger.warning(f"解析jargon失败：上下文为空，content={content}, msg_id={msg_id_str}") + continue + + entries.append({"content": content, "raw_content": [context_paragraph]}) + cached_entries = self._collect_cached_entries(messages) + if cached_entries: + entries.extend(cached_entries) + except Exception as e: + logger.error(f"解析jargon JSON失败: {e}; 原始: {response}") + return + + if not entries: + return + + # 去重并合并raw_content（按 content 聚合） + merged_entries: OrderedDict[str, Dict[str, List[str]]] = OrderedDict() + for entry in entries: + content_key = entry["content"] + raw_list = entry.get("raw_content", []) or [] + if content_key in merged_entries: + merged_entries[content_key]["raw_content"].extend(raw_list) + else: + merged_entries[content_key] = { + "content": content_key, + "raw_content": list(raw_list), + } + + uniq_entries = [] + for merged_entry in merged_entries.values(): + raw_content_list = merged_entry["raw_content"] + if raw_content_list: + merged_entry["raw_content"] = list(dict.fromkeys(raw_content_list)) + uniq_entries.append(merged_entry) + + saved = 0 + updated = 0 + for entry in uniq_entries: + content = entry["content"] + raw_content_list = entry["raw_content"] # 已经是列表 + + try: + # 查询所有content匹配的记录 + query = Jargon.select().where(Jargon.content == content) + + # 查找匹配的记录 + matched_obj = None + for obj in query: + if global_config.expression.all_global_jargon: + # 开启all_global：所有content匹配的记录都可以 + matched_obj = obj + break + else: + # 关闭all_global：需要检查chat_id列表是否包含目标chat_id + chat_id_list = parse_chat_id_list(obj.chat_id) + if chat_id_list_contains(chat_id_list, self.chat_id): + matched_obj = obj + break + + if matched_obj: + obj = matched_obj + try: + obj.count = (obj.count or 0) + 1 + except Exception: + obj.count = 1 + + # 合并raw_content列表：读取现有列表，追加新值，去重 + existing_raw_content = [] + if obj.raw_content: + try: + existing_raw_content = ( + json.loads(obj.raw_content) + if isinstance(obj.raw_content, str) + else obj.raw_content + ) + if not isinstance(existing_raw_content, list): + existing_raw_content = [existing_raw_content] if existing_raw_content else [] + except (json.JSONDecodeError, TypeError): + existing_raw_content = [obj.raw_content] if obj.raw_content else [] + + # 合并并去重 + merged_list = list(dict.fromkeys(existing_raw_content + raw_content_list)) + obj.raw_content = json.dumps(merged_list, ensure_ascii=False) + + # 更新chat_id列表：增加当前chat_id的计数 + chat_id_list = parse_chat_id_list(obj.chat_id) + updated_chat_id_list = update_chat_id_list(chat_id_list, self.chat_id, increment=1) + obj.chat_id = json.dumps(updated_chat_id_list, ensure_ascii=False) + + # 开启all_global时，确保记录标记为is_global=True + if global_config.expression.all_global_jargon: + obj.is_global = True + # 关闭all_global时，保持原有is_global不变（不修改） + + obj.save() + + # 检查是否需要推断（达到阈值且超过上次判定值） + if _should_infer_meaning(obj): + # 异步触发推断，不阻塞主流程 + # 重新加载对象以确保数据最新 + jargon_id = obj.id + asyncio.create_task(self._infer_meaning_by_id(jargon_id)) + + updated += 1 + else: + # 没找到匹配记录，创建新记录 + if global_config.expression.all_global_jargon: + # 开启all_global：新记录默认为is_global=True + is_global_new = True + else: + # 关闭all_global：新记录is_global=False + is_global_new = False + + # 使用新格式创建chat_id列表：[[chat_id, count]] + chat_id_list = [[self.chat_id, 1]] + chat_id_json = json.dumps(chat_id_list, ensure_ascii=False) + + Jargon.create( + content=content, + raw_content=json.dumps(raw_content_list, ensure_ascii=False), + chat_id=chat_id_json, + is_global=is_global_new, + count=1, + ) + saved += 1 + except Exception as e: + logger.error(f"保存jargon失败: chat_id={self.chat_id}, content={content}, err={e}") + continue + finally: + self._add_to_cache(content) + + # 固定输出提取的jargon结果，格式化为可读形式（只要有提取结果就输出） + if uniq_entries: + # 收集所有提取的jargon内容 + jargon_list = [entry["content"] for entry in uniq_entries] + jargon_str = ",".join(jargon_list) + + # 输出格式化的结果（使用logger.info会自动应用jargon模块的颜色） + logger.info(f"[{self.stream_name}]疑似黑话: {jargon_str}") + + if saved or updated: + logger.info(f"jargon写入: 新增 {saved} 条，更新 {updated} 条，chat_id={self.chat_id}") + except Exception as e: + logger.error(f"JargonMiner 运行失败: {e}") + # 即使失败也保持时间戳更新，避免频繁重试 + + async def process_extracted_entries( + self, + entries: List[Dict[str, List[str]]], + person_name_filter: Optional[Callable[[str], bool]] = None + ) -> None: + """ + 处理已提取的黑话条目（从 expression_learner 路由过来的） + + Args: + entries: 黑话条目列表，每个元素格式为 {"content": "...", "raw_content": [...]} + person_name_filter: 可选的过滤函数，用于检查内容是否包含人物名称 + """ + if not entries: + return + + try: + # 去重并合并raw_content（按 content 聚合） + merged_entries: OrderedDict[str, Dict[str, List[str]]] = OrderedDict() + for entry in entries: + content_key = entry["content"] + + # 检查是否包含人物名称 + # logger.info(f"process_extracted_entries 检查是否包含人物名称: {content_key}") + # logger.info(f"person_name_filter: {person_name_filter}") + if person_name_filter and person_name_filter(content_key): + logger.info(f"process_extracted_entries 跳过包含人物名称的黑话: {content_key}") + continue + + raw_list = entry.get("raw_content", []) or [] + if content_key in merged_entries: + merged_entries[content_key]["raw_content"].extend(raw_list) + else: + merged_entries[content_key] = { + "content": content_key, + "raw_content": list(raw_list), + } + + uniq_entries = [] + for merged_entry in merged_entries.values(): + raw_content_list = merged_entry["raw_content"] + if raw_content_list: + merged_entry["raw_content"] = list(dict.fromkeys(raw_content_list)) + uniq_entries.append(merged_entry) + + saved = 0 + updated = 0 + for entry in uniq_entries: + content = entry["content"] + raw_content_list = entry["raw_content"] # 已经是列表 + + try: + # 查询所有content匹配的记录 + query = Jargon.select().where(Jargon.content == content) + + # 查找匹配的记录 + matched_obj = None + for obj in query: + if global_config.expression.all_global_jargon: + # 开启all_global：所有content匹配的记录都可以 + matched_obj = obj + break + else: + # 关闭all_global：需要检查chat_id列表是否包含目标chat_id + chat_id_list = parse_chat_id_list(obj.chat_id) + if chat_id_list_contains(chat_id_list, self.chat_id): + matched_obj = obj + break + + if matched_obj: + obj = matched_obj + try: + obj.count = (obj.count or 0) + 1 + except Exception: + obj.count = 1 + + # 合并raw_content列表：读取现有列表，追加新值，去重 + existing_raw_content = [] + if obj.raw_content: + try: + existing_raw_content = ( + json.loads(obj.raw_content) if isinstance(obj.raw_content, str) else obj.raw_content + ) + if not isinstance(existing_raw_content, list): + existing_raw_content = [existing_raw_content] if existing_raw_content else [] + except (json.JSONDecodeError, TypeError): + existing_raw_content = [obj.raw_content] if obj.raw_content else [] + + # 合并并去重 + merged_list = list(dict.fromkeys(existing_raw_content + raw_content_list)) + obj.raw_content = json.dumps(merged_list, ensure_ascii=False) + + # 更新chat_id列表：增加当前chat_id的计数 + chat_id_list = parse_chat_id_list(obj.chat_id) + updated_chat_id_list = update_chat_id_list(chat_id_list, self.chat_id, increment=1) + obj.chat_id = json.dumps(updated_chat_id_list, ensure_ascii=False) + + # 开启all_global时，确保记录标记为is_global=True + if global_config.expression.all_global_jargon: + obj.is_global = True + # 关闭all_global时，保持原有is_global不变（不修改） + + obj.save() + + # 检查是否需要推断（达到阈值且超过上次判定值） + if _should_infer_meaning(obj): + # 异步触发推断，不阻塞主流程 + # 重新加载对象以确保数据最新 + jargon_id = obj.id + asyncio.create_task(self._infer_meaning_by_id(jargon_id)) + + updated += 1 + else: + # 没找到匹配记录，创建新记录 + if global_config.expression.all_global_jargon: + # 开启all_global：新记录默认为is_global=True + is_global_new = True + else: + # 关闭all_global：新记录is_global=False + is_global_new = False + + # 使用新格式创建chat_id列表：[[chat_id, count]] + chat_id_list = [[self.chat_id, 1]] + chat_id_json = json.dumps(chat_id_list, ensure_ascii=False) + + Jargon.create( + content=content, + raw_content=json.dumps(raw_content_list, ensure_ascii=False), + chat_id=chat_id_json, + is_global=is_global_new, + count=1, + ) + saved += 1 + except Exception as e: + logger.error(f"保存jargon失败: chat_id={self.chat_id}, content={content}, err={e}") + continue + finally: + self._add_to_cache(content) + + # 固定输出提取的jargon结果，格式化为可读形式（只要有提取结果就输出） + if uniq_entries: + # 收集所有提取的jargon内容 + jargon_list = [entry["content"] for entry in uniq_entries] + jargon_str = ",".join(jargon_list) + + # 输出格式化的结果（使用logger.info会自动应用jargon模块的颜色） + logger.info(f"[{self.stream_name}]疑似黑话: {jargon_str}") + + if saved or updated: + logger.debug(f"jargon写入: 新增 {saved} 条，更新 {updated} 条，chat_id={self.chat_id}") + except Exception as e: + logger.error(f"处理已提取的黑话条目失败: {e}") + + +class JargonMinerManager: + def __init__(self) -> None: + self._miners: dict[str, JargonMiner] = {} + + def get_miner(self, chat_id: str) -> JargonMiner: + if chat_id not in self._miners: + self._miners[chat_id] = JargonMiner(chat_id) + return self._miners[chat_id] + + +miner_manager = JargonMinerManager() + + +def search_jargon( + keyword: str, chat_id: Optional[str] = None, limit: int = 10, case_sensitive: bool = False, fuzzy: bool = True +) -> List[Dict[str, str]]: + """ + 搜索jargon，支持大小写不敏感和模糊搜索 + + Args: + keyword: 搜索关键词 + chat_id: 可选的聊天ID + - 如果开启了all_global：此参数被忽略，查询所有is_global=True的记录 + - 如果关闭了all_global：如果提供则优先搜索该聊天或global的jargon + limit: 返回结果数量限制，默认10 + case_sensitive: 是否大小写敏感，默认False（不敏感） + fuzzy: 是否模糊搜索，默认True（使用LIKE匹配） + + Returns: + List[Dict[str, str]]: 包含content, meaning的字典列表 + """ + if not keyword or not keyword.strip(): + return [] + + keyword = keyword.strip() + + # 构建查询（选择所有需要的字段，以便后续过滤） + query = Jargon.select() + + # 构建搜索条件 + if case_sensitive: + # 大小写敏感 + if fuzzy: + # 模糊搜索 + search_condition = Jargon.content.contains(keyword) + else: + # 精确匹配 + search_condition = Jargon.content == keyword + else: + # 大小写不敏感 + if fuzzy: + # 模糊搜索（使用LOWER函数） + search_condition = fn.LOWER(Jargon.content).contains(keyword.lower()) + else: + # 精确匹配（使用LOWER函数） + search_condition = fn.LOWER(Jargon.content) == keyword.lower() + + query = query.where(search_condition) + + # 根据all_global配置决定查询逻辑 + if global_config.expression.all_global_jargon: + # 开启all_global：所有记录都是全局的，查询所有is_global=True的记录（无视chat_id） + query = query.where(Jargon.is_global) + # 注意：对于all_global=False的情况，chat_id过滤在Python层面进行，以便兼容新旧格式 + + # 注意：meaning的过滤移到Python层面，因为我们需要先过滤chat_id + + # 按count降序排序，优先返回出现频率高的 + query = query.order_by(Jargon.count.desc()) + + # 限制结果数量（先多取一些，因为后面可能过滤） + query = query.limit(limit * 2) + + # 执行查询并返回结果，过滤chat_id + results = [] + for jargon in query: + # 如果提供了chat_id且all_global=False，需要检查chat_id列表是否包含目标chat_id + if chat_id and not global_config.expression.all_global_jargon: + chat_id_list = parse_chat_id_list(jargon.chat_id) + # 如果记录是is_global=True，或者chat_id列表包含目标chat_id，则包含 + if not jargon.is_global and not chat_id_list_contains(chat_id_list, chat_id): + continue + + # 只返回有meaning的记录 + if not jargon.meaning or jargon.meaning.strip() == "": + continue + + results.append({"content": jargon.content or "", "meaning": jargon.meaning or ""}) + + # 达到限制数量后停止 + if len(results) >= limit: + break + + return results diff --git a/src/bw_learner/learner_utils.py b/src/bw_learner/learner_utils.py new file mode 100644 index 00000000..e871dde7 --- /dev/null +++ b/src/bw_learner/learner_utils.py @@ -0,0 +1,380 @@ +import re +import difflib +import random +import json +from datetime import datetime +from typing import Optional, List, Dict, Any + +from src.common.logger import get_logger +from src.config.config import global_config +from src.chat.utils.chat_message_builder import ( + build_readable_messages, +) +from src.chat.utils.utils import parse_platform_accounts + + +logger = get_logger("learner_utils") + + +def filter_message_content(content: Optional[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 calculate_similarity(text1: str, text2: str) -> float: + """ + 计算两个文本的相似度，返回0-1之间的值 + 使用SequenceMatcher计算相似度 + + Args: + text1: 第一个文本 + text2: 第二个文本 + + Returns: + float: 相似度值，范围0-1 + """ + return difflib.SequenceMatcher(None, text1, text2).ratio() + + +def calculate_style_similarity(style1: str, style2: str) -> float: + """ + 计算两个 style 的相似度，返回0-1之间的值 + 在计算前会移除"使用"和"句式"这两个词（参考 expression_similarity_analysis.py） + + Args: + style1: 第一个 style + style2: 第二个 style + + Returns: + float: 相似度值，范围0-1 + """ + if not style1 or not style2: + return 0.0 + + # 移除"使用"和"句式"这两个词 + def remove_ignored_words(text: str) -> str: + """移除需要忽略的词""" + text = text.replace("使用", "") + text = text.replace("句式", "") + return text.strip() + + cleaned_style1 = remove_ignored_words(style1) + cleaned_style2 = remove_ignored_words(style2) + + # 如果清理后文本为空，返回0 + if not cleaned_style1 or not cleaned_style2: + return 0.0 + + return difflib.SequenceMatcher(None, cleaned_style1, cleaned_style2).ratio() + + +def format_create_date(timestamp: float) -> str: + """ + 将时间戳格式化为可读的日期字符串 + + Args: + timestamp: 时间戳 + + Returns: + str: 格式化后的日期字符串 + """ + try: + return datetime.fromtimestamp(timestamp).strftime("%Y-%m-%d %H:%M:%S") + except (ValueError, OSError): + return "未知时间" + + +def _compute_weights(population: List[Dict]) -> List[float]: + """ + 根据表达的count计算权重，范围限定在1~5之间。 + count越高，权重越高，但最多为基础权重的5倍。 + 如果表达已checked，权重会再乘以3倍。 + """ + if not population: + return [] + + counts = [] + checked_flags = [] + for item in population: + count = item.get("count", 1) + try: + count_value = float(count) + except (TypeError, ValueError): + count_value = 1.0 + counts.append(max(count_value, 0.0)) + # 获取checked状态 + checked = item.get("checked", False) + checked_flags.append(bool(checked)) + + min_count = min(counts) + max_count = max(counts) + + if max_count == min_count: + base_weights = [1.0 for _ in counts] + else: + base_weights = [] + for count_value in counts: + # 线性映射到[1,5]区间 + normalized = (count_value - min_count) / (max_count - min_count) + base_weights.append(1.0 + normalized * 4.0) # 1~5 + + # 如果checked，权重乘以3 + weights = [] + for base_weight, checked in zip(base_weights, checked_flags, strict=False): + if checked: + weights.append(base_weight * 3.0) + else: + weights.append(base_weight) + return weights + + +def weighted_sample(population: List[Dict], k: int) -> List[Dict]: + """ + 随机抽样函数 + + Args: + population: 总体数据列表 + k: 需要抽取的数量 + + Returns: + List[Dict]: 抽取的数据列表 + """ + if not population or k <= 0: + return [] + + if len(population) <= k: + return population.copy() + + selected: List[Dict] = [] + population_copy = population.copy() + + for _ in range(min(k, len(population_copy))): + weights = _compute_weights(population_copy) + total_weight = sum(weights) + if total_weight <= 0: + # 回退到均匀随机 + idx = random.randint(0, len(population_copy) - 1) + selected.append(population_copy.pop(idx)) + continue + + threshold = random.uniform(0, total_weight) + cumulative = 0.0 + for idx, weight in enumerate(weights): + cumulative += weight + if threshold <= cumulative: + selected.append(population_copy.pop(idx)) + break + + return selected + + +def parse_chat_id_list(chat_id_value: Any) -> List[List[Any]]: + """ + 解析chat_id字段，兼容旧格式（字符串）和新格式（JSON列表） + + Args: + chat_id_value: 可能是字符串（旧格式）或JSON字符串（新格式） + + Returns: + List[List[Any]]: 格式为 [[chat_id, count], ...] 的列表 + """ + if not chat_id_value: + return [] + + # 如果是字符串，尝试解析为JSON + if isinstance(chat_id_value, str): + # 尝试解析JSON + try: + parsed = json.loads(chat_id_value) + if isinstance(parsed, list): + # 新格式：已经是列表 + return parsed + elif isinstance(parsed, str): + # 解析后还是字符串，说明是旧格式 + return [[parsed, 1]] + else: + # 其他类型，当作旧格式处理 + return [[str(chat_id_value), 1]] + except (json.JSONDecodeError, TypeError): + # 解析失败，当作旧格式（纯字符串） + return [[str(chat_id_value), 1]] + elif isinstance(chat_id_value, list): + # 已经是列表格式 + return chat_id_value + else: + # 其他类型，转换为旧格式 + return [[str(chat_id_value), 1]] + + +def update_chat_id_list(chat_id_list: List[List[Any]], target_chat_id: str, increment: int = 1) -> List[List[Any]]: + """ + 更新chat_id列表，如果target_chat_id已存在则增加计数，否则添加新条目 + + Args: + chat_id_list: 当前的chat_id列表，格式为 [[chat_id, count], ...] + target_chat_id: 要更新或添加的chat_id + increment: 增加的计数，默认为1 + + Returns: + List[List[Any]]: 更新后的chat_id列表 + """ + item = _find_chat_id_item(chat_id_list, target_chat_id) + if item is not None: + # 找到匹配的chat_id，增加计数 + if len(item) >= 2: + item[1] = (item[1] if isinstance(item[1], (int, float)) else 0) + increment + else: + item.append(increment) + else: + # 未找到，添加新条目 + chat_id_list.append([target_chat_id, increment]) + + return chat_id_list + + +def _find_chat_id_item(chat_id_list: List[List[Any]], target_chat_id: str) -> Optional[List[Any]]: + """ + 在chat_id列表中查找匹配的项（辅助函数） + + Args: + chat_id_list: chat_id列表，格式为 [[chat_id, count], ...] + target_chat_id: 要查找的chat_id + + Returns: + 如果找到则返回匹配的项，否则返回None + """ + for item in chat_id_list: + if isinstance(item, list) and len(item) >= 1 and str(item[0]) == str(target_chat_id): + return item + return None + + +def chat_id_list_contains(chat_id_list: List[List[Any]], target_chat_id: str) -> bool: + """ + 检查chat_id列表中是否包含指定的chat_id + + Args: + chat_id_list: chat_id列表，格式为 [[chat_id, count], ...] + target_chat_id: 要查找的chat_id + + Returns: + bool: 如果包含则返回True + """ + return _find_chat_id_item(chat_id_list, target_chat_id) is not None + + +def contains_bot_self_name(content: str) -> bool: + """ + 判断词条是否包含机器人的昵称或别名 + """ + if not content: + return False + + bot_config = getattr(global_config, "bot", None) + if not bot_config: + return False + + target = content.strip().lower() + nickname = str(getattr(bot_config, "nickname", "") or "").strip().lower() + alias_names = [str(alias or "").strip().lower() for alias in getattr(bot_config, "alias_names", []) or []] + + candidates = [name for name in [nickname, *alias_names] if name] + + return any(name in target for name in candidates) + + +def build_context_paragraph(messages: List[Any], center_index: int) -> Optional[str]: + """ + 构建包含中心消息上下文的段落（前3条+后3条），使用标准的 readable builder 输出 + """ + if not messages or center_index < 0 or center_index >= len(messages): + return None + + context_start = max(0, center_index - 3) + context_end = min(len(messages), center_index + 1 + 3) + context_messages = messages[context_start:context_end] + + if not context_messages: + return None + + try: + paragraph = build_readable_messages( + messages=context_messages, + replace_bot_name=True, + timestamp_mode="relative", + read_mark=0.0, + truncate=False, + show_actions=False, + show_pic=True, + message_id_list=None, + remove_emoji_stickers=False, + pic_single=True, + ) + except Exception as e: + logger.warning(f"构建上下文段落失败: {e}") + return None + + paragraph = paragraph.strip() + return paragraph or None + + +def is_bot_message(msg: Any) -> bool: + """判断消息是否来自机器人自身""" + if msg is None: + return False + + bot_config = getattr(global_config, "bot", None) + if not bot_config: + return False + + platform = ( + str(getattr(msg, "user_platform", "") or getattr(getattr(msg, "user_info", None), "platform", "") or "") + .strip() + .lower() + ) + user_id = str(getattr(msg, "user_id", "") or getattr(getattr(msg, "user_info", None), "user_id", "") or "").strip() + + if not platform or not user_id: + return False + + platform_accounts = {} + try: + platform_accounts = parse_platform_accounts(getattr(bot_config, "platforms", []) or []) + except Exception: + platform_accounts = {} + + bot_accounts: Dict[str, str] = {} + qq_account = str(getattr(bot_config, "qq_account", "") or "").strip() + if qq_account: + bot_accounts["qq"] = qq_account + + telegram_account = str(getattr(bot_config, "telegram_account", "") or "").strip() + if telegram_account: + bot_accounts["telegram"] = telegram_account + + for plat, account in platform_accounts.items(): + if account and plat not in bot_accounts: + bot_accounts[plat] = account + + bot_account = bot_accounts.get(platform) + return bool(bot_account and user_id == bot_account) diff --git a/src/bw_learner/message_recorder.py b/src/bw_learner/message_recorder.py new file mode 100644 index 00000000..4d8a5015 --- /dev/null +++ b/src/bw_learner/message_recorder.py @@ -0,0 +1,212 @@ +import time +import asyncio +from typing import List, Any +from src.common.logger import get_logger +from src.config.config import global_config +from src.chat.message_receive.chat_stream import get_chat_manager +from src.chat.utils.chat_message_builder import get_raw_msg_by_timestamp_with_chat_inclusive +from src.bw_learner.expression_learner import expression_learner_manager +from src.bw_learner.jargon_miner import miner_manager + +logger = get_logger("bw_learner") + + +class MessageRecorder: + """ + 统一的消息记录器，负责管理时间窗口和消息提取，并将消息分发给 expression_learner 和 jargon_miner + """ + + def __init__(self, chat_id: str) -> None: + 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_extraction_time: float = time.time() + + # 提取锁，防止并发执行 + self._extraction_lock = asyncio.Lock() + + # 获取 expression 和 jargon 的配置参数 + self._init_parameters() + + # 获取 expression_learner 和 jargon_miner 实例 + self.expression_learner = expression_learner_manager.get_expression_learner(chat_id) + self.jargon_miner = miner_manager.get_miner(chat_id) + + def _init_parameters(self) -> None: + """初始化提取参数""" + # 获取 expression 配置 + _, self.enable_expression_learning, self.enable_jargon_learning = ( + global_config.expression.get_expression_config_for_chat(self.chat_id) + ) + self.min_messages_for_extraction = 30 + self.min_extraction_interval = 60 + + logger.debug( + f"MessageRecorder 初始化: chat_id={self.chat_id}, " + f"min_messages={self.min_messages_for_extraction}, " + f"min_interval={self.min_extraction_interval}" + ) + + def should_trigger_extraction(self) -> bool: + """ + 检查是否应该触发消息提取 + + Returns: + bool: 是否应该触发提取 + """ + # 检查时间间隔 + time_diff = time.time() - self.last_extraction_time + if time_diff < self.min_extraction_interval: + return False + + # 检查消息数量 + recent_messages = get_raw_msg_by_timestamp_with_chat_inclusive( + chat_id=self.chat_id, + timestamp_start=self.last_extraction_time, + timestamp_end=time.time(), + ) + + if not recent_messages or len(recent_messages) < self.min_messages_for_extraction: + return False + + return True + + async def extract_and_distribute(self) -> None: + """ + 提取消息并分发给 expression_learner 和 jargon_miner + """ + # 使用异步锁防止并发执行 + async with self._extraction_lock: + # 在锁内检查，避免并发触发 + if not self.should_trigger_extraction(): + return + + # 检查 chat_stream 是否存在 + if not self.chat_stream: + return + + # 记录本次提取的时间窗口，避免重复提取 + extraction_start_time = self.last_extraction_time + extraction_end_time = time.time() + + # 立即更新提取时间，防止并发触发 + self.last_extraction_time = extraction_end_time + + try: + # logger.info(f"在聊天流 {self.chat_name} 开始统一消息提取和分发") + + # 拉取提取窗口内的消息 + messages = get_raw_msg_by_timestamp_with_chat_inclusive( + chat_id=self.chat_id, + timestamp_start=extraction_start_time, + timestamp_end=extraction_end_time, + ) + + if not messages: + logger.debug(f"聊天流 {self.chat_name} 没有新消息，跳过提取") + return + + # 按时间排序，确保顺序一致 + messages = sorted(messages, key=lambda msg: msg.time or 0) + + logger.info( + f"聊天流 {self.chat_name} 提取到 {len(messages)} 条消息，" + f"时间窗口: {extraction_start_time:.2f} - {extraction_end_time:.2f}" + ) + + # 分别触发 expression_learner 和 jargon_miner 的处理 + # 传递提取的消息，避免它们重复获取 + # 触发 expression 学习（如果启用） + if self.enable_expression_learning: + asyncio.create_task( + self._trigger_expression_learning(extraction_start_time, extraction_end_time, messages) + ) + + # 触发 jargon 提取（如果启用），传递消息 + # if self.enable_jargon_learning: + # asyncio.create_task( + # self._trigger_jargon_extraction(extraction_start_time, extraction_end_time, messages) + # ) + + except Exception as e: + logger.error(f"为聊天流 {self.chat_name} 提取和分发消息失败: {e}") + import traceback + + traceback.print_exc() + # 即使失败也保持时间戳更新，避免频繁重试 + + async def _trigger_expression_learning( + self, timestamp_start: float, timestamp_end: float, messages: List[Any] + ) -> None: + """ + 触发 expression 学习，使用指定的消息列表 + + Args: + timestamp_start: 开始时间戳 + timestamp_end: 结束时间戳 + messages: 消息列表 + """ + try: + # 传递消息给 ExpressionLearner（必需参数） + learnt_style = await self.expression_learner.learn_and_store(messages=messages) + + if learnt_style: + logger.info(f"聊天流 {self.chat_name} 表达学习完成") + else: + logger.debug(f"聊天流 {self.chat_name} 表达学习未获得有效结果") + except Exception as e: + logger.error(f"为聊天流 {self.chat_name} 触发表达学习失败: {e}") + import traceback + + traceback.print_exc() + + async def _trigger_jargon_extraction( + self, timestamp_start: float, timestamp_end: float, messages: List[Any] + ) -> None: + """ + 触发 jargon 提取，使用指定的消息列表 + + Args: + timestamp_start: 开始时间戳 + timestamp_end: 结束时间戳 + messages: 消息列表 + """ + try: + # 传递消息给 JargonMiner，避免它重复获取 + await self.jargon_miner.run_once(messages=messages) + + except Exception as e: + logger.error(f"为聊天流 {self.chat_name} 触发黑话提取失败: {e}") + import traceback + + traceback.print_exc() + + +class MessageRecorderManager: + """MessageRecorder 管理器""" + + def __init__(self) -> None: + self._recorders: dict[str, MessageRecorder] = {} + + def get_recorder(self, chat_id: str) -> MessageRecorder: + """获取或创建指定 chat_id 的 MessageRecorder""" + if chat_id not in self._recorders: + self._recorders[chat_id] = MessageRecorder(chat_id) + return self._recorders[chat_id] + + +# 全局管理器实例 +recorder_manager = MessageRecorderManager() + + +async def extract_and_distribute_messages(chat_id: str) -> None: + """ + 统一的消息提取和分发入口函数 + + Args: + chat_id: 聊天流ID + """ + recorder = recorder_manager.get_recorder(chat_id) + await recorder.extract_and_distribute() diff --git a/src/bw_learner/reflect_tracker.py b/src/bw_learner/reflect_tracker.py new file mode 100644 index 00000000..c792679d --- /dev/null +++ b/src/bw_learner/reflect_tracker.py @@ -0,0 +1,199 @@ +import time +from typing import Optional, Dict, TYPE_CHECKING +from src.common.logger import get_logger +from src.common.database.database_model import Expression +from src.llm_models.utils_model import LLMRequest +from src.chat.utils.prompt_builder import Prompt, global_prompt_manager +from src.config.config import model_config +from src.chat.message_receive.chat_stream import ChatStream +from src.chat.utils.chat_message_builder import ( + get_raw_msg_by_timestamp_with_chat, + build_readable_messages, +) + +if TYPE_CHECKING: + pass + +logger = get_logger("reflect_tracker") + + +class ReflectTracker: + def __init__(self, chat_stream: ChatStream, expression: Expression, created_time: float): + self.chat_stream = chat_stream + self.expression = expression + self.created_time = created_time + # self.message_count = 0 # Replaced by checking message list length + self.last_check_msg_count = 0 + self.max_message_count = 30 + self.max_duration = 15 * 60 # 15 minutes + + # LLM for judging response + self.judge_model = LLMRequest(model_set=model_config.model_task_config.utils, request_type="reflect.tracker") + + self._init_prompts() + + def _init_prompts(self): + judge_prompt = """ +你是一个表达反思助手。Bot之前询问了表达方式是否合适。 +你需要根据提供的上下文对话，判断是否对该表达方式做出了肯定或否定的评价。 + +**询问内容** +情景: {situation} +风格: {style} + +**上下文对话** +{context_block} + +**判断要求** +1. 判断对话中是否包含对上述询问的回答。 +2. 如果是，判断是肯定（Approve）还是否定（Reject），或者是提供了修改意见。 +3. 如果不是回答，或者是无关内容，请返回 "Ignore"。 +4. 如果是否定并提供了修改意见，请提取修正后的情景和风格。 + +请输出JSON格式： +```json +{{ + "judgment": "Approve" | "Reject" | "Ignore", + "corrected_situation": "...", // 如果有修改意见，提取修正后的情景，否则留空 + "corrected_style": "..." // 如果有修改意见，提取修正后的风格，否则留空 +}} +``` +""" + Prompt(judge_prompt, "reflect_judge_prompt") + + async def trigger_tracker(self) -> bool: + """ + 触发追踪检查 + Returns: True if resolved (should destroy tracker), False otherwise + """ + # Check timeout + if time.time() - self.created_time > self.max_duration: + logger.info(f"ReflectTracker for expr {self.expression.id} timed out (duration).") + return True + + # Fetch messages since creation + msg_list = get_raw_msg_by_timestamp_with_chat( + chat_id=self.chat_stream.stream_id, + timestamp_start=self.created_time, + timestamp_end=time.time(), + ) + + current_msg_count = len(msg_list) + + # Check message limit + if current_msg_count > self.max_message_count: + logger.info(f"ReflectTracker for expr {self.expression.id} timed out (message count).") + return True + + # If no new messages since last check, skip + if current_msg_count <= self.last_check_msg_count: + return False + + self.last_check_msg_count = current_msg_count + + # Build context block + # Use simple readable format + context_block = build_readable_messages( + msg_list, + replace_bot_name=True, + timestamp_mode="relative", + read_mark=0.0, + show_actions=False, + ) + + # LLM Judge + try: + prompt = await global_prompt_manager.format_prompt( + "reflect_judge_prompt", + situation=self.expression.situation, + style=self.expression.style, + context_block=context_block, + ) + + logger.info(f"ReflectTracker LLM Prompt: {prompt}") + + response, _ = await self.judge_model.generate_response_async(prompt, temperature=0.1) + + logger.info(f"ReflectTracker LLM Response: {response}") + + # Parse JSON + import json + import re + from json_repair import repair_json + + json_pattern = r"```json\s*(.*?)\s*```" + matches = re.findall(json_pattern, response, re.DOTALL) + if not matches: + # Try to parse raw response if no code block + matches = [response] + + json_obj = json.loads(repair_json(matches[0])) + + judgment = json_obj.get("judgment") + + if judgment == "Approve": + self.expression.checked = True + self.expression.rejected = False + self.expression.save() + logger.info(f"Expression {self.expression.id} approved by operator.") + return True + + elif judgment == "Reject": + self.expression.checked = True + corrected_situation = json_obj.get("corrected_situation") + corrected_style = json_obj.get("corrected_style") + + # 检查是否有更新 + has_update = bool(corrected_situation or corrected_style) + + if corrected_situation: + self.expression.situation = corrected_situation + if corrected_style: + self.expression.style = corrected_style + + # 如果拒绝但未更新，标记为 rejected=1 + if not has_update: + self.expression.rejected = True + else: + self.expression.rejected = False + + self.expression.save() + + if has_update: + logger.info( + f"Expression {self.expression.id} rejected and updated by operator. New situation: {corrected_situation}, New style: {corrected_style}" + ) + else: + logger.info( + f"Expression {self.expression.id} rejected but no correction provided, marked as rejected=1." + ) + return True + + elif judgment == "Ignore": + logger.info(f"ReflectTracker for expr {self.expression.id} judged as Ignore.") + return False + + except Exception as e: + logger.error(f"Error in ReflectTracker check: {e}") + return False + + return False + + +# Global manager for trackers +class ReflectTrackerManager: + def __init__(self): + self.trackers: Dict[str, ReflectTracker] = {} # chat_id -> tracker + + def add_tracker(self, chat_id: str, tracker: ReflectTracker): + self.trackers[chat_id] = tracker + + def get_tracker(self, chat_id: str) -> Optional[ReflectTracker]: + return self.trackers.get(chat_id) + + def remove_tracker(self, chat_id: str): + if chat_id in self.trackers: + del self.trackers[chat_id] + + +reflect_tracker_manager = ReflectTrackerManager() diff --git a/src/chat/brain_chat/PFC/action_planner.py b/src/chat/brain_chat/PFC/action_planner.py new file mode 100644 index 00000000..4770c6ce --- /dev/null +++ b/src/chat/brain_chat/PFC/action_planner.py @@ -0,0 +1,491 @@ +import time +from typing import Tuple, Optional # 增加了 Optional +from src.common.logger_manager import get_logger +from ..models.utils_model import LLMRequest +from ...config.config import global_config +from .chat_observer import ChatObserver +from .pfc_utils import get_items_from_json +from src.individuality.individuality import Individuality +from .observation_info import ObservationInfo +from .conversation_info import ConversationInfo +from src.plugins.utils.chat_message_builder import build_readable_messages + + +logger = get_logger("pfc_action_planner") + + +# --- 定义 Prompt 模板 --- + +# Prompt(1): 首次回复或非连续回复时的决策 Prompt +PROMPT_INITIAL_REPLY = """{persona_text}。现在你在参与一场QQ私聊，请根据以下【所有信息】审慎且灵活的决策下一步行动，可以回复，可以倾听，可以调取知识，甚至可以屏蔽对方： + +【当前对话目标】 +{goals_str} +{knowledge_info_str} + +【最近行动历史概要】 +{action_history_summary} +【上一次行动的详细情况和结果】 +{last_action_context} +【时间和超时提示】 +{time_since_last_bot_message_info}{timeout_context} +【最近的对话记录】(包括你已成功发送的消息 和 新收到的消息) +{chat_history_text} + +------ +可选行动类型以及解释： +fetch_knowledge: 需要调取知识或记忆，当需要专业知识或特定信息时选择，对方若提到你不太认识的人名或实体也可以尝试选择 +listening: 倾听对方发言，当你认为对方话才说到一半，发言明显未结束时选择 +direct_reply: 直接回复对方 +rethink_goal: 思考一个对话目标，当你觉得目前对话需要目标，或当前目标不再适用，或话题卡住时选择。注意私聊的环境是灵活的，有可能需要经常选择 +end_conversation: 结束对话，对方长时间没回复或者当你觉得对话告一段落时可以选择 +block_and_ignore: 更加极端的结束对话方式，直接结束对话并在一段时间内无视对方所有发言（屏蔽），当对话让你感到十分不适，或你遭到各类骚扰时选择 + +请以JSON格式输出你的决策： +{{ + "action": "选择的行动类型 (必须是上面列表中的一个)", + "reason": "选择该行动的详细原因 (必须有解释你是如何根据“上一次行动结果”、“对话记录”和自身设定人设做出合理判断的)" +}} + +注意：请严格按照JSON格式输出，不要包含任何其他内容。""" + +# Prompt(2): 上一次成功回复后，决定继续发言时的决策 Prompt +PROMPT_FOLLOW_UP = """{persona_text}。现在你在参与一场QQ私聊，刚刚你已经回复了对方，请根据以下【所有信息】审慎且灵活的决策下一步行动，可以继续发送新消息，可以等待，可以倾听，可以调取知识，甚至可以屏蔽对方： + +【当前对话目标】 +{goals_str} +{knowledge_info_str} + +【最近行动历史概要】 +{action_history_summary} +【上一次行动的详细情况和结果】 +{last_action_context} +【时间和超时提示】 +{time_since_last_bot_message_info}{timeout_context} +【最近的对话记录】(包括你已成功发送的消息 和 新收到的消息) +{chat_history_text} + +------ +可选行动类型以及解释： +fetch_knowledge: 需要调取知识，当需要专业知识或特定信息时选择，对方若提到你不太认识的人名或实体也可以尝试选择 +wait: 暂时不说话，留给对方交互空间，等待对方回复（尤其是在你刚发言后、或上次发言因重复、发言过多被拒时、或不确定做什么时，这是不错的选择） +listening: 倾听对方发言（虽然你刚发过言，但如果对方立刻回复且明显话没说完，可以选择这个） +send_new_message: 发送一条新消息继续对话，允许适当的追问、补充、深入话题，或开启相关新话题。**但是避免在因重复被拒后立即使用，也不要在对方没有回复的情况下过多的“消息轰炸”或重复发言** +rethink_goal: 思考一个对话目标，当你觉得目前对话需要目标，或当前目标不再适用，或话题卡住时选择。注意私聊的环境是灵活的，有可能需要经常选择 +end_conversation: 结束对话，对方长时间没回复或者当你觉得对话告一段落时可以选择 +block_and_ignore: 更加极端的结束对话方式，直接结束对话并在一段时间内无视对方所有发言（屏蔽），当对话让你感到十分不适，或你遭到各类骚扰时选择 + +请以JSON格式输出你的决策： +{{ + "action": "选择的行动类型 (必须是上面列表中的一个)", + "reason": "选择该行动的详细原因 (必须有解释你是如何根据“上一次行动结果”、“对话记录”和自身设定人设做出合理判断的。请说明你为什么选择继续发言而不是等待，以及打算发送什么类型的新消息连续发言，必须记录已经发言了几次)" +}} + +注意：请严格按照JSON格式输出，不要包含任何其他内容。""" + +# 新增：Prompt(3): 决定是否在结束对话前发送告别语 +PROMPT_END_DECISION = """{persona_text}。刚刚你决定结束一场 QQ 私聊。 + +【你们之前的聊天记录】 +{chat_history_text} + +你觉得你们的对话已经完整结束了吗？有时候，在对话自然结束后再说点什么可能会有点奇怪，但有时也可能需要一条简短的消息来圆满结束。 +如果觉得确实有必要再发一条简短、自然、符合你人设的告别消息（比如 "好，下次再聊~" 或 "嗯，先这样吧"），就输出 "yes"。 +如果觉得当前状态下直接结束对话更好，没有必要再发消息，就输出 "no"。 + +请以 JSON 格式输出你的选择： +{{ + "say_bye": "yes/no", + "reason": "选择 yes 或 no 的原因和内心想法 (简要说明)" +}} + +注意：请严格按照 JSON 格式输出，不要包含任何其他内容。""" + + +# ActionPlanner 类定义，顶格 +class ActionPlanner: + """行动规划器""" + + def __init__(self, stream_id: str, private_name: str): + self.llm = LLMRequest( + model=global_config.llm_PFC_action_planner, + temperature=global_config.llm_PFC_action_planner["temp"], + max_tokens=1500, + request_type="action_planning", + ) + self.personality_info = Individuality.get_instance().get_prompt(x_person=2, level=3) + self.name = global_config.BOT_NICKNAME + self.private_name = private_name + self.chat_observer = ChatObserver.get_instance(stream_id, private_name) + # self.action_planner_info = ActionPlannerInfo() # 移除未使用的变量 + + # 修改 plan 方法签名，增加 last_successful_reply_action 参数 + async def plan( + self, + observation_info: ObservationInfo, + conversation_info: ConversationInfo, + last_successful_reply_action: Optional[str], + ) -> Tuple[str, str]: + """规划下一步行动 + + Args: + observation_info: 决策信息 + conversation_info: 对话信息 + last_successful_reply_action: 上一次成功的回复动作类型 ('direct_reply' 或 'send_new_message' 或 None) + + Returns: + Tuple[str, str]: (行动类型, 行动原因) + """ + # --- 获取 Bot 上次发言时间信息 --- + # (这部分逻辑不变) + time_since_last_bot_message_info = "" + try: + bot_id = str(global_config.BOT_QQ) + if hasattr(observation_info, "chat_history") and observation_info.chat_history: + for i in range(len(observation_info.chat_history) - 1, -1, -1): + msg = observation_info.chat_history[i] + if not isinstance(msg, dict): + continue + sender_info = msg.get("user_info", {}) + sender_id = str(sender_info.get("user_id")) if isinstance(sender_info, dict) else None + msg_time = msg.get("time") + if sender_id == bot_id and msg_time: + time_diff = time.time() - msg_time + if time_diff < 60.0: + time_since_last_bot_message_info = ( + f"提示：你上一条成功发送的消息是在 {time_diff:.1f} 秒前。\n" + ) + break + else: + logger.debug( + f"[私聊][{self.private_name}]Observation info chat history is empty or not available for bot time check." + ) + except AttributeError: + logger.warning( + f"[私聊][{self.private_name}]ObservationInfo object might not have chat_history attribute yet for bot time check." + ) + except Exception as e: + logger.warning(f"[私聊][{self.private_name}]获取 Bot 上次发言时间时出错: {e}") + + # --- 获取超时提示信息 --- + # (这部分逻辑不变) + timeout_context = "" + try: + if hasattr(conversation_info, "goal_list") and conversation_info.goal_list: + last_goal_dict = conversation_info.goal_list[-1] + if isinstance(last_goal_dict, dict) and "goal" in last_goal_dict: + last_goal_text = last_goal_dict["goal"] + if isinstance(last_goal_text, str) and "分钟，思考接下来要做什么" in last_goal_text: + try: + timeout_minutes_text = last_goal_text.split("，")[0].replace("你等待了", "") + timeout_context = f"重要提示：对方已经长时间（{timeout_minutes_text}）没有回复你的消息了（这可能代表对方繁忙/不想回复/没注意到你的消息等情况，或在对方看来本次聊天已告一段落），请基于此情况规划下一步。\n" + except Exception: + timeout_context = "重要提示：对方已经长时间没有回复你的消息了（这可能代表对方繁忙/不想回复/没注意到你的消息等情况，或在对方看来本次聊天已告一段落），请基于此情况规划下一步。\n" + else: + logger.debug( + f"[私聊][{self.private_name}]Conversation info goal_list is empty or not available for timeout check." + ) + except AttributeError: + logger.warning( + f"[私聊][{self.private_name}]ConversationInfo object might not have goal_list attribute yet for timeout check." + ) + except Exception as e: + logger.warning(f"[私聊][{self.private_name}]检查超时目标时出错: {e}") + + # --- 构建通用 Prompt 参数 --- + logger.debug( + f"[私聊][{self.private_name}]开始规划行动：当前目标: {getattr(conversation_info, 'goal_list', '不可用')}" + ) + + # 构建对话目标 (goals_str) + goals_str = "" + try: + if hasattr(conversation_info, "goal_list") and conversation_info.goal_list: + for goal_reason in conversation_info.goal_list: + if isinstance(goal_reason, dict): + goal = goal_reason.get("goal", "目标内容缺失") + reasoning = goal_reason.get("reasoning", "没有明确原因") + else: + goal = str(goal_reason) + reasoning = "没有明确原因" + + goal = str(goal) if goal is not None else "目标内容缺失" + reasoning = str(reasoning) if reasoning is not None else "没有明确原因" + goals_str += f"- 目标：{goal}\n 原因：{reasoning}\n" + + if not goals_str: + goals_str = "- 目前没有明确对话目标，请考虑设定一个。\n" + else: + goals_str = "- 目前没有明确对话目标，请考虑设定一个。\n" + except AttributeError: + logger.warning( + f"[私聊][{self.private_name}]ConversationInfo object might not have goal_list attribute yet." + ) + goals_str = "- 获取对话目标时出错。\n" + except Exception as e: + logger.error(f"[私聊][{self.private_name}]构建对话目标字符串时出错: {e}") + goals_str = "- 构建对话目标时出错。\n" + + # --- 知识信息字符串构建开始 --- + knowledge_info_str = "【已获取的相关知识和记忆】\n" + try: + # 检查 conversation_info 是否有 knowledge_list 并且不为空 + if hasattr(conversation_info, "knowledge_list") and conversation_info.knowledge_list: + # 最多只显示最近的 5 条知识，防止 Prompt 过长 + recent_knowledge = conversation_info.knowledge_list[-5:] + for i, knowledge_item in enumerate(recent_knowledge): + if isinstance(knowledge_item, dict): + query = knowledge_item.get("query", "未知查询") + knowledge = knowledge_item.get("knowledge", "无知识内容") + source = knowledge_item.get("source", "未知来源") + # 只取知识内容的前 2000 个字，避免太长 + knowledge_snippet = knowledge[:2000] + "..." if len(knowledge) > 2000 else knowledge + knowledge_info_str += ( + f"{i + 1}. 关于 '{query}' 的知识 (来源: {source}):\n {knowledge_snippet}\n" + ) + else: + # 处理列表里不是字典的异常情况 + knowledge_info_str += f"{i + 1}. 发现一条格式不正确的知识记录。\n" + + if not recent_knowledge: # 如果 knowledge_list 存在但为空 + knowledge_info_str += "- 暂无相关知识和记忆。\n" + + else: + # 如果 conversation_info 没有 knowledge_list 属性，或者列表为空 + knowledge_info_str += "- 暂无相关知识记忆。\n" + except AttributeError: + logger.warning(f"[私聊][{self.private_name}]ConversationInfo 对象可能缺少 knowledge_list 属性。") + knowledge_info_str += "- 获取知识列表时出错。\n" + except Exception as e: + logger.error(f"[私聊][{self.private_name}]构建知识信息字符串时出错: {e}") + knowledge_info_str += "- 处理知识列表时出错。\n" + # --- 知识信息字符串构建结束 --- + + # 获取聊天历史记录 (chat_history_text) + try: + if hasattr(observation_info, "chat_history") and observation_info.chat_history: + chat_history_text = observation_info.chat_history_str + if not chat_history_text: + chat_history_text = "还没有聊天记录。\n" + else: + chat_history_text = "还没有聊天记录。\n" + + if hasattr(observation_info, "new_messages_count") and observation_info.new_messages_count > 0: + if hasattr(observation_info, "unprocessed_messages") and observation_info.unprocessed_messages: + new_messages_list = observation_info.unprocessed_messages + new_messages_str = await build_readable_messages( + new_messages_list, + replace_bot_name=True, + merge_messages=False, + timestamp_mode="relative", + read_mark=0.0, + ) + chat_history_text += ( + f"\n--- 以下是 {observation_info.new_messages_count} 条新消息 ---\n{new_messages_str}" + ) + else: + logger.warning( + f"[私聊][{self.private_name}]ObservationInfo has new_messages_count > 0 but unprocessed_messages is empty or missing." + ) + except AttributeError: + logger.warning( + f"[私聊][{self.private_name}]ObservationInfo object might be missing expected attributes for chat history." + ) + chat_history_text = "获取聊天记录时出错。\n" + except Exception as e: + logger.error(f"[私聊][{self.private_name}]处理聊天记录时发生未知错误: {e}") + chat_history_text = "处理聊天记录时出错。\n" + + # 构建 Persona 文本 (persona_text) + persona_text = f"你的名字是{self.name}，{self.personality_info}。" + + # 构建行动历史和上一次行动结果 (action_history_summary, last_action_context) + # (这部分逻辑不变) + action_history_summary = "你最近执行的行动历史：\n" + last_action_context = "关于你【上一次尝试】的行动：\n" + action_history_list = [] + try: + if hasattr(conversation_info, "done_action") and conversation_info.done_action: + action_history_list = conversation_info.done_action[-5:] + else: + logger.debug(f"[私聊][{self.private_name}]Conversation info done_action is empty or not available.") + except AttributeError: + logger.warning( + f"[私聊][{self.private_name}]ConversationInfo object might not have done_action attribute yet." + ) + except Exception as e: + logger.error(f"[私聊][{self.private_name}]访问行动历史时出错: {e}") + + if not action_history_list: + action_history_summary += "- 还没有执行过行动。\n" + last_action_context += "- 这是你规划的第一个行动。\n" + else: + for i, action_data in enumerate(action_history_list): + action_type = "未知" + plan_reason = "未知" + status = "未知" + final_reason = "" + action_time = "" + + if isinstance(action_data, dict): + action_type = action_data.get("action", "未知") + plan_reason = action_data.get("plan_reason", "未知规划原因") + status = action_data.get("status", "未知") + final_reason = action_data.get("final_reason", "") + action_time = action_data.get("time", "") + elif isinstance(action_data, tuple): + # 假设旧格式兼容 + if len(action_data) > 0: + action_type = action_data[0] + if len(action_data) > 1: + plan_reason = action_data[1] # 可能是规划原因或最终原因 + if len(action_data) > 2: + status = action_data[2] + if status == "recall" and len(action_data) > 3: + final_reason = action_data[3] + elif status == "done" and action_type in ["direct_reply", "send_new_message"]: + plan_reason = "成功发送" # 简化显示 + + reason_text = f", 失败/取消原因: {final_reason}" if final_reason else "" + summary_line = f"- 时间:{action_time}, 尝试行动:'{action_type}', 状态:{status}{reason_text}" + action_history_summary += summary_line + "\n" + + if i == len(action_history_list) - 1: + last_action_context += f"- 上次【规划】的行动是: '{action_type}'\n" + last_action_context += f"- 当时规划的【原因】是: {plan_reason}\n" + if status == "done": + last_action_context += "- 该行动已【成功执行】。\n" + # 记录这次成功的行动类型，供下次决策 + # self.last_successful_action_type = action_type # 不在这里记录，由 conversation 控制 + elif status == "recall": + last_action_context += "- 但该行动最终【未能执行/被取消】。\n" + if final_reason: + last_action_context += f"- 【重要】失败/取消的具体原因是: “{final_reason}”\n" + else: + last_action_context += "- 【重要】失败/取消原因未明确记录。\n" + # self.last_successful_action_type = None # 行动失败，清除记录 + else: + last_action_context += f"- 该行动当前状态: {status}\n" + # self.last_successful_action_type = None # 非完成状态，清除记录 + + # --- 选择 Prompt --- + if last_successful_reply_action in ["direct_reply", "send_new_message"]: + prompt_template = PROMPT_FOLLOW_UP + logger.debug(f"[私聊][{self.private_name}]使用 PROMPT_FOLLOW_UP (追问决策)") + else: + prompt_template = PROMPT_INITIAL_REPLY + logger.debug(f"[私聊][{self.private_name}]使用 PROMPT_INITIAL_REPLY (首次/非连续回复决策)") + + # --- 格式化最终的 Prompt --- + prompt = prompt_template.format( + persona_text=persona_text, + goals_str=goals_str if goals_str.strip() else "- 目前没有明确对话目标，请考虑设定一个。", + action_history_summary=action_history_summary, + last_action_context=last_action_context, + time_since_last_bot_message_info=time_since_last_bot_message_info, + timeout_context=timeout_context, + chat_history_text=chat_history_text if chat_history_text.strip() else "还没有聊天记录。", + knowledge_info_str=knowledge_info_str, + ) + + logger.debug(f"[私聊][{self.private_name}]发送到LLM的最终提示词:\n------\n{prompt}\n------") + try: + content, _ = await self.llm.generate_response_async(prompt) + logger.debug(f"[私聊][{self.private_name}]LLM (行动规划) 原始返回内容: {content}") + + # --- 初始行动规划解析 --- + success, initial_result = get_items_from_json( + content, + self.private_name, + "action", + "reason", + default_values={"action": "wait", "reason": "LLM返回格式错误或未提供原因，默认等待"}, + ) + + initial_action = initial_result.get("action", "wait") + initial_reason = initial_result.get("reason", "LLM未提供原因，默认等待") + + # 检查是否需要进行结束对话决策 --- + if initial_action == "end_conversation": + logger.info(f"[私聊][{self.private_name}]初步规划结束对话，进入告别决策...") + + # 使用新的 PROMPT_END_DECISION + end_decision_prompt = PROMPT_END_DECISION.format( + persona_text=persona_text, # 复用之前的 persona_text + chat_history_text=chat_history_text, # 复用之前的 chat_history_text + ) + + logger.debug( + f"[私聊][{self.private_name}]发送到LLM的结束决策提示词:\n------\n{end_decision_prompt}\n------" + ) + try: + end_content, _ = await self.llm.generate_response_async(end_decision_prompt) # 再次调用LLM + logger.debug(f"[私聊][{self.private_name}]LLM (结束决策) 原始返回内容: {end_content}") + + # 解析结束决策的JSON + end_success, end_result = get_items_from_json( + end_content, + self.private_name, + "say_bye", + "reason", + default_values={"say_bye": "no", "reason": "结束决策LLM返回格式错误，默认不告别"}, + required_types={"say_bye": str, "reason": str}, # 明确类型 + ) + + say_bye_decision = end_result.get("say_bye", "no").lower() # 转小写方便比较 + end_decision_reason = end_result.get("reason", "未提供原因") + + if end_success and say_bye_decision == "yes": + # 决定要告别，返回新的 'say_goodbye' 动作 + logger.info( + f"[私聊][{self.private_name}]结束决策: yes, 准备生成告别语. 原因: {end_decision_reason}" + ) + # 注意：这里的 reason 可以考虑拼接初始原因和结束决策原因，或者只用结束决策原因 + final_action = "say_goodbye" + final_reason = f"决定发送告别语。决策原因: {end_decision_reason} (原结束理由: {initial_reason})" + return final_action, final_reason + else: + # 决定不告别 (包括解析失败或明确说no) + logger.info( + f"[私聊][{self.private_name}]结束决策: no, 直接结束对话. 原因: {end_decision_reason}" + ) + # 返回原始的 'end_conversation' 动作 + final_action = "end_conversation" + final_reason = initial_reason # 保持原始的结束理由 + return final_action, final_reason + + except Exception as end_e: + logger.error(f"[私聊][{self.private_name}]调用结束决策LLM或处理结果时出错: {str(end_e)}") + # 出错时，默认执行原始的结束对话 + logger.warning(f"[私聊][{self.private_name}]结束决策出错，将按原计划执行 end_conversation") + return "end_conversation", initial_reason # 返回原始动作和原因 + + else: + action = initial_action + reason = initial_reason + + # 验证action类型 (保持不变) + valid_actions = [ + "direct_reply", + "send_new_message", + "fetch_knowledge", + "wait", + "listening", + "rethink_goal", + "end_conversation", # 仍然需要验证，因为可能从上面决策后返回 + "block_and_ignore", + "say_goodbye", # 也要验证这个新动作 + ] + if action not in valid_actions: + logger.warning(f"[私聊][{self.private_name}]LLM返回了未知的行动类型: '{action}'，强制改为 wait") + reason = f"(原始行动'{action}'无效，已强制改为wait) {reason}" + action = "wait" + + logger.info(f"[私聊][{self.private_name}]规划的行动: {action}") + logger.info(f"[私聊][{self.private_name}]行动原因: {reason}") + return action, reason + + except Exception as e: + # 外层异常处理保持不变 + logger.error(f"[私聊][{self.private_name}]规划行动时调用 LLM 或处理结果出错: {str(e)}") + return "wait", f"行动规划处理中发生错误，暂时等待: {str(e)}" diff --git a/src/chat/brain_chat/PFC/chat_observer.py b/src/chat/brain_chat/PFC/chat_observer.py new file mode 100644 index 00000000..22cbf27d --- /dev/null +++ b/src/chat/brain_chat/PFC/chat_observer.py @@ -0,0 +1,379 @@ +import time +import asyncio +import traceback +from typing import Optional, Dict, Any, List +from src.common.logger import get_module_logger +from maim_message import UserInfo +from ...config.config import global_config +from .chat_states import NotificationManager, create_new_message_notification, create_cold_chat_notification +from .message_storage import MongoDBMessageStorage +from rich.traceback import install + +install(extra_lines=3) + +logger = get_module_logger("chat_observer") + + +class ChatObserver: + """聊天状态观察器""" + + # 类级别的实例管理 + _instances: Dict[str, "ChatObserver"] = {} + + @classmethod + def get_instance(cls, stream_id: str, private_name: str) -> "ChatObserver": + """获取或创建观察器实例 + + Args: + stream_id: 聊天流ID + private_name: 私聊名称 + + Returns: + ChatObserver: 观察器实例 + """ + if stream_id not in cls._instances: + cls._instances[stream_id] = cls(stream_id, private_name) + return cls._instances[stream_id] + + def __init__(self, stream_id: str, private_name: str): + """初始化观察器 + + Args: + stream_id: 聊天流ID + """ + self.last_check_time = None + self.last_bot_speak_time = None + self.last_user_speak_time = None + if stream_id in self._instances: + raise RuntimeError(f"ChatObserver for {stream_id} already exists. Use get_instance() instead.") + + self.stream_id = stream_id + self.private_name = private_name + self.message_storage = MongoDBMessageStorage() + + # self.last_user_speak_time: Optional[float] = None # 对方上次发言时间 + # self.last_bot_speak_time: Optional[float] = None # 机器人上次发言时间 + # self.last_check_time: float = time.time() # 上次查看聊天记录时间 + self.last_message_read: Optional[Dict[str, Any]] = None # 最后读取的消息ID + self.last_message_time: float = time.time() + + self.waiting_start_time: float = time.time() # 等待开始时间，初始化为当前时间 + + # 运行状态 + self._running: bool = False + self._task: Optional[asyncio.Task] = None + self._update_event = asyncio.Event() # 触发更新的事件 + self._update_complete = asyncio.Event() # 更新完成的事件 + + # 通知管理器 + self.notification_manager = NotificationManager() + + # 冷场检查配置 + self.cold_chat_threshold: float = 60.0 # 60秒无消息判定为冷场 + self.last_cold_chat_check: float = time.time() + self.is_cold_chat_state: bool = False + + self.update_event = asyncio.Event() + self.update_interval = 2 # 更新间隔（秒） + self.message_cache = [] + self.update_running = False + + async def check(self) -> bool: + """检查距离上一次观察之后是否有了新消息 + + Returns: + bool: 是否有新消息 + """ + logger.debug(f"[私聊][{self.private_name}]检查距离上一次观察之后是否有了新消息: {self.last_check_time}") + + new_message_exists = await self.message_storage.has_new_messages(self.stream_id, self.last_check_time) + + if new_message_exists: + logger.debug(f"[私聊][{self.private_name}]发现新消息") + self.last_check_time = time.time() + + return new_message_exists + + async def _add_message_to_history(self, message: Dict[str, Any]): + """添加消息到历史记录并发送通知 + + Args: + message: 消息数据 + """ + try: + # 发送新消息通知 + notification = create_new_message_notification( + sender="chat_observer", target="observation_info", message=message + ) + # print(self.notification_manager) + await self.notification_manager.send_notification(notification) + except Exception as e: + logger.error(f"[私聊][{self.private_name}]添加消息到历史记录时出错: {e}") + print(traceback.format_exc()) + + # 检查并更新冷场状态 + await self._check_cold_chat() + + async def _check_cold_chat(self): + """检查是否处于冷场状态并发送通知""" + current_time = time.time() + + # 每10秒检查一次冷场状态 + if current_time - self.last_cold_chat_check < 10: + return + + self.last_cold_chat_check = current_time + + # 判断是否冷场 + is_cold = ( + True + if self.last_message_time is None + else (current_time - self.last_message_time) > self.cold_chat_threshold + ) + + # 如果冷场状态发生变化，发送通知 + if is_cold != self.is_cold_chat_state: + self.is_cold_chat_state = is_cold + notification = create_cold_chat_notification(sender="chat_observer", target="pfc", is_cold=is_cold) + await self.notification_manager.send_notification(notification) + + def new_message_after(self, time_point: float) -> bool: + """判断是否在指定时间点后有新消息 + + Args: + time_point: 时间戳 + + Returns: + bool: 是否有新消息 + """ + + if self.last_message_time is None: + logger.debug(f"[私聊][{self.private_name}]没有最后消息时间，返回 False") + return False + + has_new = self.last_message_time > time_point + logger.debug( + f"[私聊][{self.private_name}]判断是否在指定时间点后有新消息: {self.last_message_time} > {time_point} = {has_new}" + ) + return has_new + + def get_message_history( + self, + start_time: Optional[float] = None, + end_time: Optional[float] = None, + limit: Optional[int] = None, + user_id: Optional[str] = None, + ) -> List[Dict[str, Any]]: + """获取消息历史 + + Args: + start_time: 开始时间戳 + end_time: 结束时间戳 + limit: 限制返回消息数量 + user_id: 指定用户ID + + Returns: + List[Dict[str, Any]]: 消息列表 + """ + filtered_messages = self.message_history + + if start_time is not None: + filtered_messages = [m for m in filtered_messages if m["time"] >= start_time] + + if end_time is not None: + filtered_messages = [m for m in filtered_messages if m["time"] <= end_time] + + if user_id is not None: + filtered_messages = [ + m for m in filtered_messages if UserInfo.from_dict(m.get("user_info", {})).user_id == user_id + ] + + if limit is not None: + filtered_messages = filtered_messages[-limit:] + + return filtered_messages + + async def _fetch_new_messages(self) -> List[Dict[str, Any]]: + """获取新消息 + + Returns: + List[Dict[str, Any]]: 新消息列表 + """ + new_messages = await self.message_storage.get_messages_after(self.stream_id, self.last_message_time) + + if new_messages: + self.last_message_read = new_messages[-1] + self.last_message_time = new_messages[-1]["time"] + + # print(f"获取数据库中找到的新消息: {new_messages}") + + return new_messages + + async def _fetch_new_messages_before(self, time_point: float) -> List[Dict[str, Any]]: + """获取指定时间点之前的消息 + + Args: + time_point: 时间戳 + + Returns: + List[Dict[str, Any]]: 最多5条消息 + """ + new_messages = await self.message_storage.get_messages_before(self.stream_id, time_point) + + if new_messages: + self.last_message_read = new_messages[-1]["message_id"] + + logger.debug(f"[私聊][{self.private_name}]获取指定时间点111之前的消息: {new_messages}") + + return new_messages + + """主要观察循环""" + + async def _update_loop(self): + """更新循环""" + # try: + # start_time = time.time() + # messages = await self._fetch_new_messages_before(start_time) + # for message in messages: + # await self._add_message_to_history(message) + # logger.debug(f"[私聊][{self.private_name}]缓冲消息: {messages}") + # except Exception as e: + # logger.error(f"[私聊][{self.private_name}]缓冲消息出错: {e}") + + while self._running: + try: + # 等待事件或超时（1秒） + try: + # print("等待事件") + await asyncio.wait_for(self._update_event.wait(), timeout=1) + + except asyncio.TimeoutError: + # print("超时") + pass # 超时后也执行一次检查 + + self._update_event.clear() # 重置触发事件 + self._update_complete.clear() # 重置完成事件 + + # 获取新消息 + new_messages = await self._fetch_new_messages() + + if new_messages: + # 处理新消息 + for message in new_messages: + await self._add_message_to_history(message) + + # 设置完成事件 + self._update_complete.set() + + except Exception as e: + logger.error(f"[私聊][{self.private_name}]更新循环出错: {e}") + logger.error(f"[私聊][{self.private_name}]{traceback.format_exc()}") + self._update_complete.set() # 即使出错也要设置完成事件 + + def trigger_update(self): + """触发一次立即更新""" + self._update_event.set() + + async def wait_for_update(self, timeout: float = 5.0) -> bool: + """等待更新完成 + + Args: + timeout: 超时时间（秒） + + Returns: + bool: 是否成功完成更新（False表示超时） + """ + try: + await asyncio.wait_for(self._update_complete.wait(), timeout=timeout) + return True + except asyncio.TimeoutError: + logger.warning(f"[私聊][{self.private_name}]等待更新完成超时（{timeout}秒）") + return False + + def start(self): + """启动观察器""" + if self._running: + return + + self._running = True + self._task = asyncio.create_task(self._update_loop()) + logger.debug(f"[私聊][{self.private_name}]ChatObserver for {self.stream_id} started") + + def stop(self): + """停止观察器""" + self._running = False + self._update_event.set() # 设置事件以解除等待 + self._update_complete.set() # 设置完成事件以解除等待 + if self._task: + self._task.cancel() + logger.debug(f"[私聊][{self.private_name}]ChatObserver for {self.stream_id} stopped") + + async def process_chat_history(self, messages: list): + """处理聊天历史 + + Args: + messages: 消息列表 + """ + self.update_check_time() + + for msg in messages: + try: + user_info = UserInfo.from_dict(msg.get("user_info", {})) + if user_info.user_id == global_config.BOT_QQ: + self.update_bot_speak_time(msg["time"]) + else: + self.update_user_speak_time(msg["time"]) + except Exception as e: + logger.warning(f"[私聊][{self.private_name}]处理消息时间时出错: {e}") + continue + + def update_check_time(self): + """更新查看时间""" + self.last_check_time = time.time() + + def update_bot_speak_time(self, speak_time: Optional[float] = None): + """更新机器人说话时间""" + self.last_bot_speak_time = speak_time or time.time() + + def update_user_speak_time(self, speak_time: Optional[float] = None): + """更新用户说话时间""" + self.last_user_speak_time = speak_time or time.time() + + def get_time_info(self) -> str: + """获取时间信息文本""" + current_time = time.time() + time_info = "" + + if self.last_bot_speak_time: + bot_speak_ago = current_time - self.last_bot_speak_time + time_info += f"\n距离你上次发言已经过去了{int(bot_speak_ago)}秒" + + if self.last_user_speak_time: + user_speak_ago = current_time - self.last_user_speak_time + time_info += f"\n距离对方上次发言已经过去了{int(user_speak_ago)}秒" + + return time_info + + def get_cached_messages(self, limit: int = 50) -> List[Dict[str, Any]]: + """获取缓存的消息历史 + + Args: + limit: 获取的最大消息数量，默认50 + + Returns: + List[Dict[str, Any]]: 缓存的消息历史列表 + """ + return self.message_cache[-limit:] + + def get_last_message(self) -> Optional[Dict[str, Any]]: + """获取最后一条消息 + + Returns: + Optional[Dict[str, Any]]: 最后一条消息，如果没有则返回None + """ + if not self.message_cache: + return None + return self.message_cache[-1] + + def __str__(self): + return f"ChatObserver for {self.stream_id}" diff --git a/src/chat/brain_chat/PFC/chat_states.py b/src/chat/brain_chat/PFC/chat_states.py new file mode 100644 index 00000000..4b839b7b --- /dev/null +++ b/src/chat/brain_chat/PFC/chat_states.py @@ -0,0 +1,290 @@ +from enum import Enum, auto +from typing import Optional, Dict, Any, List, Set +from dataclasses import dataclass +from datetime import datetime +from abc import ABC, abstractmethod + + +class ChatState(Enum): + """聊天状态枚举""" + + NORMAL = auto() # 正常状态 + NEW_MESSAGE = auto() # 有新消息 + COLD_CHAT = auto() # 冷场状态 + ACTIVE_CHAT = auto() # 活跃状态 + BOT_SPEAKING = auto() # 机器人正在说话 + USER_SPEAKING = auto() # 用户正在说话 + SILENT = auto() # 沉默状态 + ERROR = auto() # 错误状态 + + +class NotificationType(Enum): + """通知类型枚举""" + + NEW_MESSAGE = auto() # 新消息通知 + COLD_CHAT = auto() # 冷场通知 + ACTIVE_CHAT = auto() # 活跃通知 + BOT_SPEAKING = auto() # 机器人说话通知 + USER_SPEAKING = auto() # 用户说话通知 + MESSAGE_DELETED = auto() # 消息删除通知 + USER_JOINED = auto() # 用户加入通知 + USER_LEFT = auto() # 用户离开通知 + ERROR = auto() # 错误通知 + + +@dataclass +class ChatStateInfo: + """聊天状态信息""" + + state: ChatState + last_message_time: Optional[float] = None + last_message_content: Optional[str] = None + last_speaker: Optional[str] = None + message_count: int = 0 + cold_duration: float = 0.0 # 冷场持续时间（秒） + active_duration: float = 0.0 # 活跃持续时间（秒） + + +@dataclass +class Notification: + """通知基类""" + + type: NotificationType + timestamp: float + sender: str # 发送者标识 + target: str # 接收者标识 + data: Dict[str, Any] + + def to_dict(self) -> Dict[str, Any]: + """转换为字典格式""" + return {"type": self.type.name, "timestamp": self.timestamp, "data": self.data} + + +@dataclass +class StateNotification(Notification): + """持续状态通知""" + + is_active: bool = True + + def to_dict(self) -> Dict[str, Any]: + base_dict = super().to_dict() + base_dict["is_active"] = self.is_active + return base_dict + + +class NotificationHandler(ABC): + """通知处理器接口""" + + @abstractmethod + async def handle_notification(self, notification: Notification): + """处理通知""" + pass + + +class NotificationManager: + """通知管理器""" + + def __init__(self): + # 按接收者和通知类型存储处理器 + self._handlers: Dict[str, Dict[NotificationType, List[NotificationHandler]]] = {} + self._active_states: Set[NotificationType] = set() + self._notification_history: List[Notification] = [] + + def register_handler(self, target: str, notification_type: NotificationType, handler: NotificationHandler): + """注册通知处理器 + + Args: + target: 接收者标识（例如："pfc"） + notification_type: 要处理的通知类型 + handler: 处理器实例 + """ + if target not in self._handlers: + self._handlers[target] = {} + if notification_type not in self._handlers[target]: + self._handlers[target][notification_type] = [] + # print(self._handlers[target][notification_type]) + self._handlers[target][notification_type].append(handler) + # print(self._handlers[target][notification_type]) + + def unregister_handler(self, target: str, notification_type: NotificationType, handler: NotificationHandler): + """注销通知处理器 + + Args: + target: 接收者标识 + notification_type: 通知类型 + handler: 要注销的处理器实例 + """ + if target in self._handlers and notification_type in self._handlers[target]: + handlers = self._handlers[target][notification_type] + if handler in handlers: + handlers.remove(handler) + # 如果该类型的处理器列表为空，删除该类型 + if not handlers: + del self._handlers[target][notification_type] + # 如果该目标没有任何处理器，删除该目标 + if not self._handlers[target]: + del self._handlers[target] + + async def send_notification(self, notification: Notification): + """发送通知""" + self._notification_history.append(notification) + + # 如果是状态通知，更新活跃状态 + if isinstance(notification, StateNotification): + if notification.is_active: + self._active_states.add(notification.type) + else: + self._active_states.discard(notification.type) + + # 调用目标接收者的处理器 + target = notification.target + if target in self._handlers: + handlers = self._handlers[target].get(notification.type, []) + # print(handlers) + for handler in handlers: + # print(f"调用处理器: {handler}") + await handler.handle_notification(notification) + + def get_active_states(self) -> Set[NotificationType]: + """获取当前活跃的状态""" + return self._active_states.copy() + + def is_state_active(self, state_type: NotificationType) -> bool: + """检查特定状态是否活跃""" + return state_type in self._active_states + + def get_notification_history( + self, sender: Optional[str] = None, target: Optional[str] = None, limit: Optional[int] = None + ) -> List[Notification]: + """获取通知历史 + + Args: + sender: 过滤特定发送者的通知 + target: 过滤特定接收者的通知 + limit: 限制返回数量 + """ + history = self._notification_history + + if sender: + history = [n for n in history if n.sender == sender] + if target: + history = [n for n in history if n.target == target] + + if limit is not None: + history = history[-limit:] + + return history + + def __str__(self): + str = "" + for target, handlers in self._handlers.items(): + for notification_type, handler_list in handlers.items(): + str += f"NotificationManager for {target} {notification_type} {handler_list}" + return str + + +# 一些常用的通知创建函数 +def create_new_message_notification(sender: str, target: str, message: Dict[str, Any]) -> Notification: + """创建新消息通知""" + return Notification( + type=NotificationType.NEW_MESSAGE, + timestamp=datetime.now().timestamp(), + sender=sender, + target=target, + data={ + "message_id": message.get("message_id"), + "processed_plain_text": message.get("processed_plain_text"), + "detailed_plain_text": message.get("detailed_plain_text"), + "user_info": message.get("user_info"), + "time": message.get("time"), + }, + ) + + +def create_cold_chat_notification(sender: str, target: str, is_cold: bool) -> StateNotification: + """创建冷场状态通知""" + return StateNotification( + type=NotificationType.COLD_CHAT, + timestamp=datetime.now().timestamp(), + sender=sender, + target=target, + data={"is_cold": is_cold}, + is_active=is_cold, + ) + + +def create_active_chat_notification(sender: str, target: str, is_active: bool) -> StateNotification: + """创建活跃状态通知""" + return StateNotification( + type=NotificationType.ACTIVE_CHAT, + timestamp=datetime.now().timestamp(), + sender=sender, + target=target, + data={"is_active": is_active}, + is_active=is_active, + ) + + +class ChatStateManager: + """聊天状态管理器""" + + def __init__(self): + self.current_state = ChatState.NORMAL + self.state_info = ChatStateInfo(state=ChatState.NORMAL) + self.state_history: list[ChatStateInfo] = [] + + def update_state(self, new_state: ChatState, **kwargs): + """更新聊天状态 + + Args: + new_state: 新的状态 + **kwargs: 其他状态信息 + """ + self.current_state = new_state + self.state_info.state = new_state + + # 更新其他状态信息 + for key, value in kwargs.items(): + if hasattr(self.state_info, key): + setattr(self.state_info, key, value) + + # 记录状态历史 + self.state_history.append(self.state_info) + + def get_current_state_info(self) -> ChatStateInfo: + """获取当前状态信息""" + return self.state_info + + def get_state_history(self) -> list[ChatStateInfo]: + """获取状态历史""" + return self.state_history + + def is_cold_chat(self, threshold: float = 60.0) -> bool: + """判断是否处于冷场状态 + + Args: + threshold: 冷场阈值（秒） + + Returns: + bool: 是否冷场 + """ + if not self.state_info.last_message_time: + return True + + current_time = datetime.now().timestamp() + return (current_time - self.state_info.last_message_time) > threshold + + def is_active_chat(self, threshold: float = 5.0) -> bool: + """判断是否处于活跃状态 + + Args: + threshold: 活跃阈值（秒） + + Returns: + bool: 是否活跃 + """ + if not self.state_info.last_message_time: + return False + + current_time = datetime.now().timestamp() + return (current_time - self.state_info.last_message_time) <= threshold diff --git a/src/chat/brain_chat/PFC/conversation.py b/src/chat/brain_chat/PFC/conversation.py new file mode 100644 index 00000000..0bc4cae8 --- /dev/null +++ b/src/chat/brain_chat/PFC/conversation.py @@ -0,0 +1,701 @@ +import time +import asyncio +import datetime + +# from .message_storage import MongoDBMessageStorage +from src.plugins.utils.chat_message_builder import build_readable_messages, get_raw_msg_before_timestamp_with_chat + +# from ...config.config import global_config +from typing import Dict, Any, Optional +from ..chat.message import Message +from .pfc_types import ConversationState +from .pfc import ChatObserver, GoalAnalyzer +from .message_sender import DirectMessageSender +from src.common.logger_manager import get_logger +from .action_planner import ActionPlanner +from .observation_info import ObservationInfo +from .conversation_info import ConversationInfo # 确保导入 ConversationInfo +from .reply_generator import ReplyGenerator +from ..chat.chat_stream import ChatStream +from maim_message import UserInfo +from src.plugins.chat.chat_stream import chat_manager +from .pfc_KnowledgeFetcher import KnowledgeFetcher +from .waiter import Waiter + +import traceback +from rich.traceback import install + +install(extra_lines=3) + +logger = get_logger("pfc") + + +class Conversation: + """对话类，负责管理单个对话的状态和行为""" + + def __init__(self, stream_id: str, private_name: str): + """初始化对话实例 + + Args: + stream_id: 聊天流ID + """ + self.stream_id = stream_id + self.private_name = private_name + self.state = ConversationState.INIT + self.should_continue = False + self.ignore_until_timestamp: Optional[float] = None + + # 回复相关 + self.generated_reply = "" + + async def _initialize(self): + """初始化实例，注册所有组件""" + + try: + self.action_planner = ActionPlanner(self.stream_id, self.private_name) + self.goal_analyzer = GoalAnalyzer(self.stream_id, self.private_name) + self.reply_generator = ReplyGenerator(self.stream_id, self.private_name) + self.knowledge_fetcher = KnowledgeFetcher(self.private_name) + self.waiter = Waiter(self.stream_id, self.private_name) + self.direct_sender = DirectMessageSender(self.private_name) + + # 获取聊天流信息 + self.chat_stream = chat_manager.get_stream(self.stream_id) + + self.stop_action_planner = False + except Exception as e: + logger.error(f"[私聊][{self.private_name}]初始化对话实例：注册运行组件失败: {e}") + logger.error(f"[私聊][{self.private_name}]{traceback.format_exc()}") + raise + + try: + # 决策所需要的信息，包括自身自信和观察信息两部分 + # 注册观察器和观测信息 + self.chat_observer = ChatObserver.get_instance(self.stream_id, self.private_name) + self.chat_observer.start() + self.observation_info = ObservationInfo(self.private_name) + self.observation_info.bind_to_chat_observer(self.chat_observer) + # print(self.chat_observer.get_cached_messages(limit=) + + self.conversation_info = ConversationInfo() + except Exception as e: + logger.error(f"[私聊][{self.private_name}]初始化对话实例：注册信息组件失败: {e}") + logger.error(f"[私聊][{self.private_name}]{traceback.format_exc()}") + raise + try: + logger.info(f"[私聊][{self.private_name}]为 {self.stream_id} 加载初始聊天记录...") + initial_messages = get_raw_msg_before_timestamp_with_chat( # + chat_id=self.stream_id, + timestamp=time.time(), + limit=30, # 加载最近30条作为初始上下文，可以调整 + ) + chat_talking_prompt = await build_readable_messages( + initial_messages, + replace_bot_name=True, + merge_messages=False, + timestamp_mode="relative", + read_mark=0.0, + ) + if initial_messages: + # 将加载的消息填充到 ObservationInfo 的 chat_history + self.observation_info.chat_history = initial_messages + self.observation_info.chat_history_str = chat_talking_prompt + "\n" + self.observation_info.chat_history_count = len(initial_messages) + + # 更新 ObservationInfo 中的时间戳等信息 + last_msg = initial_messages[-1] + self.observation_info.last_message_time = last_msg.get("time") + last_user_info = UserInfo.from_dict(last_msg.get("user_info", {})) + self.observation_info.last_message_sender = last_user_info.user_id + self.observation_info.last_message_content = last_msg.get("processed_plain_text", "") + + logger.info( + f"[私聊][{self.private_name}]成功加载 {len(initial_messages)} 条初始聊天记录。最后一条消息时间: {self.observation_info.last_message_time}" + ) + + # 让 ChatObserver 从加载的最后一条消息之后开始同步 + self.chat_observer.last_message_time = self.observation_info.last_message_time + self.chat_observer.last_message_read = last_msg # 更新 observer 的最后读取记录 + else: + logger.info(f"[私聊][{self.private_name}]没有找到初始聊天记录。") + + except Exception as load_err: + logger.error(f"[私聊][{self.private_name}]加载初始聊天记录时出错: {load_err}") + # 出错也要继续，只是没有历史记录而已 + # 组件准备完成，启动该论对话 + self.should_continue = True + asyncio.create_task(self.start()) + + async def start(self): + """开始对话流程""" + try: + logger.info(f"[私聊][{self.private_name}]对话系统启动中...") + asyncio.create_task(self._plan_and_action_loop()) + except Exception as e: + logger.error(f"[私聊][{self.private_name}]启动对话系统失败: {e}") + raise + + async def _plan_and_action_loop(self): + """思考步，PFC核心循环模块""" + while self.should_continue: + # 忽略逻辑 + if self.ignore_until_timestamp and time.time() < self.ignore_until_timestamp: + await asyncio.sleep(30) + continue + elif self.ignore_until_timestamp and time.time() >= self.ignore_until_timestamp: + logger.info(f"[私聊][{self.private_name}]忽略时间已到 {self.stream_id}，准备结束对话。") + self.ignore_until_timestamp = None + self.should_continue = False + continue + try: + # --- 在规划前记录当前新消息数量 --- + initial_new_message_count = 0 + if hasattr(self.observation_info, "new_messages_count"): + initial_new_message_count = self.observation_info.new_messages_count + 1 # 算上麦麦自己发的那一条 + else: + logger.warning( + f"[私聊][{self.private_name}]ObservationInfo missing 'new_messages_count' before planning." + ) + + # --- 调用 Action Planner --- + # 传递 self.conversation_info.last_successful_reply_action + action, reason = await self.action_planner.plan( + self.observation_info, self.conversation_info, self.conversation_info.last_successful_reply_action + ) + + # --- 规划后检查是否有 *更多* 新消息到达 --- + current_new_message_count = 0 + if hasattr(self.observation_info, "new_messages_count"): + current_new_message_count = self.observation_info.new_messages_count + else: + logger.warning( + f"[私聊][{self.private_name}]ObservationInfo missing 'new_messages_count' after planning." + ) + + if current_new_message_count > initial_new_message_count + 2: + logger.info( + f"[私聊][{self.private_name}]规划期间发现新增消息 ({initial_new_message_count} -> {current_new_message_count})，跳过本次行动，重新规划" + ) + # 如果规划期间有新消息，也应该重置上次回复状态，因为现在要响应新消息了 + self.conversation_info.last_successful_reply_action = None + await asyncio.sleep(0.1) + continue + + # 包含 send_new_message + if initial_new_message_count > 0 and action in ["direct_reply", "send_new_message"]: + if hasattr(self.observation_info, "clear_unprocessed_messages"): + logger.debug( + f"[私聊][{self.private_name}]准备执行 {action}，清理 {initial_new_message_count} 条规划时已知的新消息。" + ) + await self.observation_info.clear_unprocessed_messages() + if hasattr(self.observation_info, "new_messages_count"): + self.observation_info.new_messages_count = 0 + else: + logger.error( + f"[私聊][{self.private_name}]无法清理未处理消息: ObservationInfo 缺少 clear_unprocessed_messages 方法！" + ) + + await self._handle_action(action, reason, self.observation_info, self.conversation_info) + + # 检查是否需要结束对话 (逻辑不变) + goal_ended = False + if hasattr(self.conversation_info, "goal_list") and self.conversation_info.goal_list: + for goal_item in self.conversation_info.goal_list: + if isinstance(goal_item, dict): + current_goal = goal_item.get("goal") + + if current_goal == "结束对话": + goal_ended = True + break + + if goal_ended: + self.should_continue = False + logger.info(f"[私聊][{self.private_name}]检测到'结束对话'目标，停止循环。") + + except Exception as loop_err: + logger.error(f"[私聊][{self.private_name}]PFC主循环出错: {loop_err}") + logger.error(f"[私聊][{self.private_name}]{traceback.format_exc()}") + await asyncio.sleep(1) + + if self.should_continue: + await asyncio.sleep(0.1) + + logger.info(f"[私聊][{self.private_name}]PFC 循环结束 for stream_id: {self.stream_id}") + + def _check_new_messages_after_planning(self): + """检查在规划后是否有新消息""" + # 检查 ObservationInfo 是否已初始化并且有 new_messages_count 属性 + if not hasattr(self, "observation_info") or not hasattr(self.observation_info, "new_messages_count"): + logger.warning( + f"[私聊][{self.private_name}]ObservationInfo 未初始化或缺少 'new_messages_count' 属性，无法检查新消息。" + ) + return False # 或者根据需要抛出错误 + + if self.observation_info.new_messages_count > 2: + logger.info( + f"[私聊][{self.private_name}]生成/执行动作期间收到 {self.observation_info.new_messages_count} 条新消息，取消当前动作并重新规划" + ) + # 如果有新消息，也应该重置上次回复状态 + if hasattr(self, "conversation_info"): # 确保 conversation_info 已初始化 + self.conversation_info.last_successful_reply_action = None + else: + logger.warning( + f"[私聊][{self.private_name}]ConversationInfo 未初始化，无法重置 last_successful_reply_action。" + ) + return True + return False + + def _convert_to_message(self, msg_dict: Dict[str, Any]) -> Message: + """将消息字典转换为Message对象""" + try: + # 尝试从 msg_dict 直接获取 chat_stream，如果失败则从全局 chat_manager 获取 + chat_info = msg_dict.get("chat_info") + if chat_info and isinstance(chat_info, dict): + chat_stream = ChatStream.from_dict(chat_info) + elif self.chat_stream: # 使用实例变量中的 chat_stream + chat_stream = self.chat_stream + else: # Fallback: 尝试从 manager 获取 (可能需要 stream_id) + chat_stream = chat_manager.get_stream(self.stream_id) + if not chat_stream: + raise ValueError(f"无法确定 ChatStream for stream_id {self.stream_id}") + + user_info = UserInfo.from_dict(msg_dict.get("user_info", {})) + + return Message( + message_id=msg_dict.get("message_id", f"gen_{time.time()}"), # 提供默认 ID + chat_stream=chat_stream, # 使用确定的 chat_stream + time=msg_dict.get("time", time.time()), # 提供默认时间 + user_info=user_info, + processed_plain_text=msg_dict.get("processed_plain_text", ""), + detailed_plain_text=msg_dict.get("detailed_plain_text", ""), + ) + except Exception as e: + logger.warning(f"[私聊][{self.private_name}]转换消息时出错: {e}") + # 可以选择返回 None 或重新抛出异常，这里选择重新抛出以指示问题 + raise ValueError(f"无法将字典转换为 Message 对象: {e}") from e + + async def _handle_action( + self, action: str, reason: str, observation_info: ObservationInfo, conversation_info: ConversationInfo + ): + """处理规划的行动""" + + logger.debug(f"[私聊][{self.private_name}]执行行动: {action}, 原因: {reason}") + + # 记录action历史 (逻辑不变) + current_action_record = { + "action": action, + "plan_reason": reason, + "status": "start", + "time": datetime.datetime.now().strftime("%H:%M:%S"), + "final_reason": None, + } + # 确保 done_action 列表存在 + if not hasattr(conversation_info, "done_action"): + conversation_info.done_action = [] + conversation_info.done_action.append(current_action_record) + action_index = len(conversation_info.done_action) - 1 + + action_successful = False # 用于标记动作是否成功完成 + + # --- 根据不同的 action 执行 --- + + # send_new_message 失败后执行 wait + if action == "send_new_message": + max_reply_attempts = 3 + reply_attempt_count = 0 + is_suitable = False + need_replan = False + check_reason = "未进行尝试" + final_reply_to_send = "" + + while reply_attempt_count < max_reply_attempts and not is_suitable: + reply_attempt_count += 1 + logger.info( + f"[私聊][{self.private_name}]尝试生成追问回复 (第 {reply_attempt_count}/{max_reply_attempts} 次)..." + ) + self.state = ConversationState.GENERATING + + # 1. 生成回复 (调用 generate 时传入 action_type) + self.generated_reply = await self.reply_generator.generate( + observation_info, conversation_info, action_type="send_new_message" + ) + logger.info( + f"[私聊][{self.private_name}]第 {reply_attempt_count} 次生成的追问回复: {self.generated_reply}" + ) + + # 2. 检查回复 (逻辑不变) + self.state = ConversationState.CHECKING + try: + current_goal_str = conversation_info.goal_list[0]["goal"] if conversation_info.goal_list else "" + is_suitable, check_reason, need_replan = await self.reply_generator.check_reply( + reply=self.generated_reply, + goal=current_goal_str, + chat_history=observation_info.chat_history, + chat_history_str=observation_info.chat_history_str, + retry_count=reply_attempt_count - 1, + ) + logger.info( + f"[私聊][{self.private_name}]第 {reply_attempt_count} 次追问检查结果: 合适={is_suitable}, 原因='{check_reason}', 需重新规划={need_replan}" + ) + if is_suitable: + final_reply_to_send = self.generated_reply + break + elif need_replan: + logger.warning( + f"[私聊][{self.private_name}]第 {reply_attempt_count} 次追问检查建议重新规划，停止尝试。原因: {check_reason}" + ) + break + except Exception as check_err: + logger.error( + f"[私聊][{self.private_name}]第 {reply_attempt_count} 次调用 ReplyChecker (追问) 时出错: {check_err}" + ) + check_reason = f"第 {reply_attempt_count} 次检查过程出错: {check_err}" + break + + # 循环结束，处理最终结果 + if is_suitable: + # 检查是否有新消息 + if self._check_new_messages_after_planning(): + logger.info(f"[私聊][{self.private_name}]生成追问回复期间收到新消息，取消发送，重新规划行动") + conversation_info.done_action[action_index].update( + {"status": "recall", "final_reason": f"有新消息，取消发送追问: {final_reply_to_send}"} + ) + return # 直接返回，重新规划 + + # 发送合适的回复 + self.generated_reply = final_reply_to_send + # --- 在这里调用 _send_reply --- + await self._send_reply() # <--- 调用恢复后的函数 + + # 更新状态: 标记上次成功是 send_new_message + self.conversation_info.last_successful_reply_action = "send_new_message" + action_successful = True # 标记动作成功 + + elif need_replan: + # 打回动作决策 + logger.warning( + f"[私聊][{self.private_name}]经过 {reply_attempt_count} 次尝试，追问回复决定打回动作决策。打回原因: {check_reason}" + ) + conversation_info.done_action[action_index].update( + {"status": "recall", "final_reason": f"追问尝试{reply_attempt_count}次后打回: {check_reason}"} + ) + + else: + # 追问失败 + logger.warning( + f"[私聊][{self.private_name}]经过 {reply_attempt_count} 次尝试，未能生成合适的追问回复。最终原因: {check_reason}" + ) + conversation_info.done_action[action_index].update( + {"status": "recall", "final_reason": f"追问尝试{reply_attempt_count}次后失败: {check_reason}"} + ) + # 重置状态: 追问失败，下次用初始 prompt + self.conversation_info.last_successful_reply_action = None + + # 执行 Wait 操作 + logger.info(f"[私聊][{self.private_name}]由于无法生成合适追问回复，执行 'wait' 操作...") + self.state = ConversationState.WAITING + await self.waiter.wait(self.conversation_info) + wait_action_record = { + "action": "wait", + "plan_reason": "因 send_new_message 多次尝试失败而执行的后备等待", + "status": "done", + "time": datetime.datetime.now().strftime("%H:%M:%S"), + "final_reason": None, + } + conversation_info.done_action.append(wait_action_record) + + elif action == "direct_reply": + max_reply_attempts = 3 + reply_attempt_count = 0 + is_suitable = False + need_replan = False + check_reason = "未进行尝试" + final_reply_to_send = "" + + while reply_attempt_count < max_reply_attempts and not is_suitable: + reply_attempt_count += 1 + logger.info( + f"[私聊][{self.private_name}]尝试生成首次回复 (第 {reply_attempt_count}/{max_reply_attempts} 次)..." + ) + self.state = ConversationState.GENERATING + + # 1. 生成回复 + self.generated_reply = await self.reply_generator.generate( + observation_info, conversation_info, action_type="direct_reply" + ) + logger.info( + f"[私聊][{self.private_name}]第 {reply_attempt_count} 次生成的首次回复: {self.generated_reply}" + ) + + # 2. 检查回复 + self.state = ConversationState.CHECKING + try: + current_goal_str = conversation_info.goal_list[0]["goal"] if conversation_info.goal_list else "" + is_suitable, check_reason, need_replan = await self.reply_generator.check_reply( + reply=self.generated_reply, + goal=current_goal_str, + chat_history=observation_info.chat_history, + chat_history_str=observation_info.chat_history_str, + retry_count=reply_attempt_count - 1, + ) + logger.info( + f"[私聊][{self.private_name}]第 {reply_attempt_count} 次首次回复检查结果: 合适={is_suitable}, 原因='{check_reason}', 需重新规划={need_replan}" + ) + if is_suitable: + final_reply_to_send = self.generated_reply + break + elif need_replan: + logger.warning( + f"[私聊][{self.private_name}]第 {reply_attempt_count} 次首次回复检查建议重新规划，停止尝试。原因: {check_reason}" + ) + break + except Exception as check_err: + logger.error( + f"[私聊][{self.private_name}]第 {reply_attempt_count} 次调用 ReplyChecker (首次回复) 时出错: {check_err}" + ) + check_reason = f"第 {reply_attempt_count} 次检查过程出错: {check_err}" + break + + # 循环结束，处理最终结果 + if is_suitable: + # 检查是否有新消息 + if self._check_new_messages_after_planning(): + logger.info(f"[私聊][{self.private_name}]生成首次回复期间收到新消息，取消发送，重新规划行动") + conversation_info.done_action[action_index].update( + {"status": "recall", "final_reason": f"有新消息，取消发送首次回复: {final_reply_to_send}"} + ) + return # 直接返回，重新规划 + + # 发送合适的回复 + self.generated_reply = final_reply_to_send + # --- 在这里调用 _send_reply --- + await self._send_reply() # <--- 调用恢复后的函数 + + # 更新状态: 标记上次成功是 direct_reply + self.conversation_info.last_successful_reply_action = "direct_reply" + action_successful = True # 标记动作成功 + + elif need_replan: + # 打回动作决策 + logger.warning( + f"[私聊][{self.private_name}]经过 {reply_attempt_count} 次尝试，首次回复决定打回动作决策。打回原因: {check_reason}" + ) + conversation_info.done_action[action_index].update( + {"status": "recall", "final_reason": f"首次回复尝试{reply_attempt_count}次后打回: {check_reason}"} + ) + + else: + # 首次回复失败 + logger.warning( + f"[私聊][{self.private_name}]经过 {reply_attempt_count} 次尝试，未能生成合适的首次回复。最终原因: {check_reason}" + ) + conversation_info.done_action[action_index].update( + {"status": "recall", "final_reason": f"首次回复尝试{reply_attempt_count}次后失败: {check_reason}"} + ) + # 重置状态: 首次回复失败，下次还是用初始 prompt + self.conversation_info.last_successful_reply_action = None + + # 执行 Wait 操作 (保持原有逻辑) + logger.info(f"[私聊][{self.private_name}]由于无法生成合适首次回复，执行 'wait' 操作...") + self.state = ConversationState.WAITING + await self.waiter.wait(self.conversation_info) + wait_action_record = { + "action": "wait", + "plan_reason": "因 direct_reply 多次尝试失败而执行的后备等待", + "status": "done", + "time": datetime.datetime.now().strftime("%H:%M:%S"), + "final_reason": None, + } + conversation_info.done_action.append(wait_action_record) + + elif action == "fetch_knowledge": + self.state = ConversationState.FETCHING + knowledge_query = reason + try: + # 检查 knowledge_fetcher 是否存在 + if not hasattr(self, "knowledge_fetcher"): + logger.error(f"[私聊][{self.private_name}]KnowledgeFetcher 未初始化，无法获取知识。") + raise AttributeError("KnowledgeFetcher not initialized") + + knowledge, source = await self.knowledge_fetcher.fetch(knowledge_query, observation_info.chat_history) + logger.info(f"[私聊][{self.private_name}]获取到知识: {knowledge[:100]}..., 来源: {source}") + if knowledge: + # 确保 knowledge_list 存在 + if not hasattr(conversation_info, "knowledge_list"): + conversation_info.knowledge_list = [] + conversation_info.knowledge_list.append( + {"query": knowledge_query, "knowledge": knowledge, "source": source} + ) + action_successful = True + except Exception as fetch_err: + logger.error(f"[私聊][{self.private_name}]获取知识时出错: {str(fetch_err)}") + conversation_info.done_action[action_index].update( + {"status": "recall", "final_reason": f"获取知识失败: {str(fetch_err)}"} + ) + self.conversation_info.last_successful_reply_action = None # 重置状态 + + elif action == "rethink_goal": + self.state = ConversationState.RETHINKING + try: + # 检查 goal_analyzer 是否存在 + if not hasattr(self, "goal_analyzer"): + logger.error(f"[私聊][{self.private_name}]GoalAnalyzer 未初始化，无法重新思考目标。") + raise AttributeError("GoalAnalyzer not initialized") + await self.goal_analyzer.analyze_goal(conversation_info, observation_info) + action_successful = True + except Exception as rethink_err: + logger.error(f"[私聊][{self.private_name}]重新思考目标时出错: {rethink_err}") + conversation_info.done_action[action_index].update( + {"status": "recall", "final_reason": f"重新思考目标失败: {rethink_err}"} + ) + self.conversation_info.last_successful_reply_action = None # 重置状态 + + elif action == "listening": + self.state = ConversationState.LISTENING + logger.info(f"[私聊][{self.private_name}]倾听对方发言...") + try: + # 检查 waiter 是否存在 + if not hasattr(self, "waiter"): + logger.error(f"[私聊][{self.private_name}]Waiter 未初始化，无法倾听。") + raise AttributeError("Waiter not initialized") + await self.waiter.wait_listening(conversation_info) + action_successful = True # Listening 完成就算成功 + except Exception as listen_err: + logger.error(f"[私聊][{self.private_name}]倾听时出错: {listen_err}") + conversation_info.done_action[action_index].update( + {"status": "recall", "final_reason": f"倾听失败: {listen_err}"} + ) + self.conversation_info.last_successful_reply_action = None # 重置状态 + + elif action == "say_goodbye": + self.state = ConversationState.GENERATING # 也可以定义一个新的状态，如 ENDING + logger.info(f"[私聊][{self.private_name}]执行行动: 生成并发送告别语...") + try: + # 1. 生成告别语 (使用 'say_goodbye' action_type) + self.generated_reply = await self.reply_generator.generate( + observation_info, conversation_info, action_type="say_goodbye" + ) + logger.info(f"[私聊][{self.private_name}]生成的告别语: {self.generated_reply}") + + # 2. 直接发送告别语 (不经过检查) + if self.generated_reply: # 确保生成了内容 + await self._send_reply() # 调用发送方法 + # 发送成功后，标记动作成功 + action_successful = True + logger.info(f"[私聊][{self.private_name}]告别语已发送。") + else: + logger.warning(f"[私聊][{self.private_name}]未能生成告别语内容，无法发送。") + action_successful = False # 标记动作失败 + conversation_info.done_action[action_index].update( + {"status": "recall", "final_reason": "未能生成告别语内容"} + ) + + # 3. 无论是否发送成功，都准备结束对话 + self.should_continue = False + logger.info(f"[私聊][{self.private_name}]发送告别语流程结束，即将停止对话实例。") + + except Exception as goodbye_err: + logger.error(f"[私聊][{self.private_name}]生成或发送告别语时出错: {goodbye_err}") + logger.error(f"[私聊][{self.private_name}]{traceback.format_exc()}") + # 即使出错，也结束对话 + self.should_continue = False + action_successful = False # 标记动作失败 + conversation_info.done_action[action_index].update( + {"status": "recall", "final_reason": f"生成或发送告别语时出错: {goodbye_err}"} + ) + + elif action == "end_conversation": + # 这个分支现在只会在 action_planner 最终决定不告别时被调用 + self.should_continue = False + logger.info(f"[私聊][{self.private_name}]收到最终结束指令，停止对话...") + action_successful = True # 标记这个指令本身是成功的 + + elif action == "block_and_ignore": + logger.info(f"[私聊][{self.private_name}]不想再理你了...") + ignore_duration_seconds = 10 * 60 + self.ignore_until_timestamp = time.time() + ignore_duration_seconds + logger.info( + f"[私聊][{self.private_name}]将忽略此对话直到: {datetime.datetime.fromtimestamp(self.ignore_until_timestamp)}" + ) + self.state = ConversationState.IGNORED + action_successful = True # 标记动作成功 + + else: # 对应 'wait' 动作 + self.state = ConversationState.WAITING + logger.info(f"[私聊][{self.private_name}]等待更多信息...") + try: + # 检查 waiter 是否存在 + if not hasattr(self, "waiter"): + logger.error(f"[私聊][{self.private_name}]Waiter 未初始化，无法等待。") + raise AttributeError("Waiter not initialized") + _timeout_occurred = await self.waiter.wait(self.conversation_info) + action_successful = True # Wait 完成就算成功 + except Exception as wait_err: + logger.error(f"[私聊][{self.private_name}]等待时出错: {wait_err}") + conversation_info.done_action[action_index].update( + {"status": "recall", "final_reason": f"等待失败: {wait_err}"} + ) + self.conversation_info.last_successful_reply_action = None # 重置状态 + + # --- 更新 Action History 状态 --- + # 只有当动作本身成功时，才更新状态为 done + if action_successful: + conversation_info.done_action[action_index].update( + { + "status": "done", + "time": datetime.datetime.now().strftime("%H:%M:%S"), + } + ) + # 重置状态: 对于非回复类动作的成功，清除上次回复状态 + if action not in ["direct_reply", "send_new_message"]: + self.conversation_info.last_successful_reply_action = None + logger.debug(f"[私聊][{self.private_name}]动作 {action} 成功完成，重置 last_successful_reply_action") + # 如果动作是 recall 状态，在各自的处理逻辑中已经更新了 done_action + + async def _send_reply(self): + """发送回复""" + if not self.generated_reply: + logger.warning(f"[私聊][{self.private_name}]没有生成回复内容，无法发送。") + return + + try: + _current_time = time.time() + reply_content = self.generated_reply + + # 发送消息 (确保 direct_sender 和 chat_stream 有效) + if not hasattr(self, "direct_sender") or not self.direct_sender: + logger.error(f"[私聊][{self.private_name}]DirectMessageSender 未初始化，无法发送回复。") + return + if not self.chat_stream: + logger.error(f"[私聊][{self.private_name}]ChatStream 未初始化，无法发送回复。") + return + + await self.direct_sender.send_message(chat_stream=self.chat_stream, content=reply_content) + + # 发送成功后，手动触发 observer 更新可能导致重复处理自己发送的消息 + # 更好的做法是依赖 observer 的自动轮询或数据库触发器（如果支持） + # 暂时注释掉，观察是否影响 ObservationInfo 的更新 + # self.chat_observer.trigger_update() + # if not await self.chat_observer.wait_for_update(): + # logger.warning(f"[私聊][{self.private_name}]等待 ChatObserver 更新完成超时") + + self.state = ConversationState.ANALYZING # 更新状态 + + except Exception as e: + logger.error(f"[私聊][{self.private_name}]发送消息或更新状态时失败: {str(e)}") + logger.error(f"[私聊][{self.private_name}]{traceback.format_exc()}") + self.state = ConversationState.ANALYZING + + async def _send_timeout_message(self): + """发送超时结束消息""" + try: + messages = self.chat_observer.get_cached_messages(limit=1) + if not messages: + return + + latest_message = self._convert_to_message(messages[0]) + await self.direct_sender.send_message( + chat_stream=self.chat_stream, content="TODO:超时消息", reply_to_message=latest_message + ) + except Exception as e: + logger.error(f"[私聊][{self.private_name}]发送超时消息失败: {str(e)}") diff --git a/src/chat/brain_chat/PFC/conversation_info.py b/src/chat/brain_chat/PFC/conversation_info.py new file mode 100644 index 00000000..04524b69 --- /dev/null +++ b/src/chat/brain_chat/PFC/conversation_info.py @@ -0,0 +1,10 @@ +from typing import Optional + + +class ConversationInfo: + def __init__(self): + self.done_action = [] + self.goal_list = [] + self.knowledge_list = [] + self.memory_list = [] + self.last_successful_reply_action: Optional[str] = None diff --git a/src/chat/brain_chat/PFC/message_sender.py b/src/chat/brain_chat/PFC/message_sender.py new file mode 100644 index 00000000..12c2143e --- /dev/null +++ b/src/chat/brain_chat/PFC/message_sender.py @@ -0,0 +1,81 @@ +import time +from typing import Optional +from src.common.logger import get_module_logger +from ..chat.chat_stream import ChatStream +from ..chat.message import Message +from maim_message import UserInfo, Seg +from src.plugins.chat.message import MessageSending, MessageSet +from src.plugins.chat.message_sender import message_manager +from ..storage.storage import MessageStorage +from ...config.config import global_config +from rich.traceback import install + +install(extra_lines=3) + + +logger = get_module_logger("message_sender") + + +class DirectMessageSender: + """直接消息发送器""" + + def __init__(self, private_name: str): + self.private_name = private_name + self.storage = MessageStorage() + + async def send_message( + self, + chat_stream: ChatStream, + content: str, + reply_to_message: Optional[Message] = None, + ) -> None: + """发送消息到聊天流 + + Args: + chat_stream: 聊天流 + content: 消息内容 + reply_to_message: 要回复的消息（可选） + """ + try: + # 创建消息内容 + segments = Seg(type="seglist", data=[Seg(type="text", data=content)]) + + # 获取麦麦的信息 + bot_user_info = UserInfo( + user_id=global_config.BOT_QQ, + user_nickname=global_config.BOT_NICKNAME, + platform=chat_stream.platform, + ) + + # 用当前时间作为message_id，和之前那套sender一样 + message_id = f"dm{round(time.time(), 2)}" + + # 构建消息对象 + message = MessageSending( + message_id=message_id, + chat_stream=chat_stream, + bot_user_info=bot_user_info, + sender_info=reply_to_message.message_info.user_info if reply_to_message else None, + message_segment=segments, + reply=reply_to_message, + is_head=True, + is_emoji=False, + thinking_start_time=time.time(), + ) + + # 处理消息 + await message.process() + + # 不知道有什么用，先留下来了，和之前那套sender一样 + _message_json = message.to_dict() + + # 发送消息 + message_set = MessageSet(chat_stream, message_id) + message_set.add_message(message) + await message_manager.add_message(message_set) + await self.storage.store_message(message, chat_stream) + logger.info(f"[私聊][{self.private_name}]PFC消息已发送: {content}") + + except Exception as e: + logger.error(f"[私聊][{self.private_name}]PFC消息发送失败: {str(e)}") + raise diff --git a/src/chat/brain_chat/PFC/message_storage.py b/src/chat/brain_chat/PFC/message_storage.py new file mode 100644 index 00000000..cd6a01e3 --- /dev/null +++ b/src/chat/brain_chat/PFC/message_storage.py @@ -0,0 +1,119 @@ +from abc import ABC, abstractmethod +from typing import List, Dict, Any +from src.common.database import db + + +class MessageStorage(ABC): + """消息存储接口""" + + @abstractmethod + async def get_messages_after(self, chat_id: str, message: Dict[str, Any]) -> List[Dict[str, Any]]: + """获取指定消息ID之后的所有消息 + + Args: + chat_id: 聊天ID + message: 消息 + + Returns: + List[Dict[str, Any]]: 消息列表 + """ + pass + + @abstractmethod + async def get_messages_before(self, chat_id: str, time_point: float, limit: int = 5) -> List[Dict[str, Any]]: + """获取指定时间点之前的消息 + + Args: + chat_id: 聊天ID + time_point: 时间戳 + limit: 最大消息数量 + + Returns: + List[Dict[str, Any]]: 消息列表 + """ + pass + + @abstractmethod + async def has_new_messages(self, chat_id: str, after_time: float) -> bool: + """检查是否有新消息 + + Args: + chat_id: 聊天ID + after_time: 时间戳 + + Returns: + bool: 是否有新消息 + """ + pass + + +class MongoDBMessageStorage(MessageStorage): + """MongoDB消息存储实现""" + + async def get_messages_after(self, chat_id: str, message_time: float) -> List[Dict[str, Any]]: + query = {"chat_id": chat_id, "time": {"$gt": message_time}} + # print(f"storage_check_message: {message_time}") + + return list(db.messages.find(query).sort("time", 1)) + + async def get_messages_before(self, chat_id: str, time_point: float, limit: int = 5) -> List[Dict[str, Any]]: + query = {"chat_id": chat_id, "time": {"$lt": time_point}} + + messages = list(db.messages.find(query).sort("time", -1).limit(limit)) + + # 将消息按时间正序排列 + messages.reverse() + return messages + + async def has_new_messages(self, chat_id: str, after_time: float) -> bool: + query = {"chat_id": chat_id, "time": {"$gt": after_time}} + + return db.messages.find_one(query) is not None + + +# # 创建一个内存消息存储实现，用于测试 +# class InMemoryMessageStorage(MessageStorage): +# """内存消息存储实现，主要用于测试""" + +# def __init__(self): +# self.messages: Dict[str, List[Dict[str, Any]]] = {} + +# async def get_messages_after(self, chat_id: str, message_id: Optional[str] = None) -> List[Dict[str, Any]]: +# if chat_id not in self.messages: +# return [] + +# messages = self.messages[chat_id] +# if not message_id: +# return messages + +# # 找到message_id的索引 +# try: +# index = next(i for i, m in enumerate(messages) if m["message_id"] == message_id) +# return messages[index + 1:] +# except StopIteration: +# return [] + +# async def get_messages_before(self, chat_id: str, time_point: float, limit: int = 5) -> List[Dict[str, Any]]: +# if chat_id not in self.messages: +# return [] + +# messages = [ +# m for m in self.messages[chat_id] +# if m["time"] < time_point +# ] + +# return messages[-limit:] + +# async def has_new_messages(self, chat_id: str, after_time: float) -> bool: +# if chat_id not in self.messages: +# return False + +# return any(m["time"] > after_time for m in self.messages[chat_id]) + +# # 测试辅助方法 +# def add_message(self, chat_id: str, message: Dict[str, Any]): +# """添加测试消息""" +# if chat_id not in self.messages: +# self.messages[chat_id] = [] +# self.messages[chat_id].append(message) +# self.messages[chat_id].sort(key=lambda m: m["time"]) diff --git a/src/chat/brain_chat/PFC/observation_info.py b/src/chat/brain_chat/PFC/observation_info.py new file mode 100644 index 00000000..c7572955 --- /dev/null +++ b/src/chat/brain_chat/PFC/observation_info.py @@ -0,0 +1,389 @@ +from typing import List, Optional, Dict, Any, Set +from maim_message import UserInfo +import time +from src.common.logger import get_module_logger +from .chat_observer import ChatObserver +from .chat_states import NotificationHandler, NotificationType, Notification +from src.plugins.utils.chat_message_builder import build_readable_messages +import traceback # 导入 traceback 用于调试 + +logger = get_module_logger("observation_info") + + +class ObservationInfoHandler(NotificationHandler): + """ObservationInfo的通知处理器""" + + def __init__(self, observation_info: "ObservationInfo", private_name: str): + """初始化处理器 + + Args: + observation_info: 要更新的ObservationInfo实例 + private_name: 私聊对象的名称，用于日志记录 + """ + self.observation_info = observation_info + # 将 private_name 存储在 handler 实例中 + self.private_name = private_name + + async def handle_notification(self, notification: Notification): # 添加类型提示 + # 获取通知类型和数据 + notification_type = notification.type + data = notification.data + + try: # 添加错误处理块 + if notification_type == NotificationType.NEW_MESSAGE: + # 处理新消息通知 + # logger.debug(f"[私聊][{self.private_name}]收到新消息通知data: {data}") # 可以在需要时取消注释 + message_id = data.get("message_id") + processed_plain_text = data.get("processed_plain_text") + detailed_plain_text = data.get("detailed_plain_text") + user_info_dict = data.get("user_info") # 先获取字典 + time_value = data.get("time") + + # 确保 user_info 是字典类型再创建 UserInfo 对象 + user_info = None + if isinstance(user_info_dict, dict): + try: + user_info = UserInfo.from_dict(user_info_dict) + except Exception as e: + logger.error( + f"[私聊][{self.private_name}]从字典创建 UserInfo 时出错: {e}, 字典内容: {user_info_dict}" + ) + # 可以选择在这里返回或记录错误，避免后续代码出错 + return + elif user_info_dict is not None: + logger.warning( + f"[私聊][{self.private_name}]收到的 user_info 不是预期的字典类型: {type(user_info_dict)}" + ) + # 根据需要处理非字典情况，这里暂时返回 + return + + message = { + "message_id": message_id, + "processed_plain_text": processed_plain_text, + "detailed_plain_text": detailed_plain_text, + "user_info": user_info_dict, # 存储原始字典或 UserInfo 对象，取决于你的 update_from_message 如何处理 + "time": time_value, + } + # 传递 UserInfo 对象（如果成功创建）或原始字典 + await self.observation_info.update_from_message(message, user_info) # 修改：传递 user_info 对象 + + elif notification_type == NotificationType.COLD_CHAT: + # 处理冷场通知 + is_cold = data.get("is_cold", False) + await self.observation_info.update_cold_chat_status(is_cold, time.time()) # 修改：改为 await 调用 + + elif notification_type == NotificationType.ACTIVE_CHAT: + # 处理活跃通知 (通常由 COLD_CHAT 的反向状态处理) + is_active = data.get("is_active", False) + self.observation_info.is_cold = not is_active + + elif notification_type == NotificationType.BOT_SPEAKING: + # 处理机器人说话通知 (按需实现) + self.observation_info.is_typing = False + self.observation_info.last_bot_speak_time = time.time() + + elif notification_type == NotificationType.USER_SPEAKING: + # 处理用户说话通知 + self.observation_info.is_typing = False + self.observation_info.last_user_speak_time = time.time() + + elif notification_type == NotificationType.MESSAGE_DELETED: + # 处理消息删除通知 + message_id = data.get("message_id") + # 从 unprocessed_messages 中移除被删除的消息 + original_count = len(self.observation_info.unprocessed_messages) + self.observation_info.unprocessed_messages = [ + msg for msg in self.observation_info.unprocessed_messages if msg.get("message_id") != message_id + ] + if len(self.observation_info.unprocessed_messages) < original_count: + logger.info(f"[私聊][{self.private_name}]移除了未处理的消息 (ID: {message_id})") + + elif notification_type == NotificationType.USER_JOINED: + # 处理用户加入通知 (如果适用私聊场景) + user_id = data.get("user_id") + if user_id: + self.observation_info.active_users.add(str(user_id)) # 确保是字符串 + + elif notification_type == NotificationType.USER_LEFT: + # 处理用户离开通知 (如果适用私聊场景) + user_id = data.get("user_id") + if user_id: + self.observation_info.active_users.discard(str(user_id)) # 确保是字符串 + + elif notification_type == NotificationType.ERROR: + # 处理错误通知 + error_msg = data.get("error", "未提供错误信息") + logger.error(f"[私聊][{self.private_name}]收到错误通知: {error_msg}") + + except Exception as e: + logger.error(f"[私聊][{self.private_name}]处理通知时发生错误: {e}") + logger.error(traceback.format_exc()) # 打印详细堆栈信息 + + +# @dataclass <-- 这个，不需要了（递黄瓜） +class ObservationInfo: + """决策信息类，用于收集和管理来自chat_observer的通知信息 (手动实现 __init__)""" + + # 类型提示保留，可用于文档和静态分析 + private_name: str + chat_history: List[Dict[str, Any]] + chat_history_str: str + unprocessed_messages: List[Dict[str, Any]] + active_users: Set[str] + last_bot_speak_time: Optional[float] + last_user_speak_time: Optional[float] + last_message_time: Optional[float] + last_message_id: Optional[str] + last_message_content: str + last_message_sender: Optional[str] + bot_id: Optional[str] + chat_history_count: int + new_messages_count: int + cold_chat_start_time: Optional[float] + cold_chat_duration: float + is_typing: bool + is_cold_chat: bool + changed: bool + chat_observer: Optional[ChatObserver] + handler: Optional[ObservationInfoHandler] + + def __init__(self, private_name: str): + """ + 手动初始化 ObservationInfo 的所有实例变量。 + """ + + # 接收的参数 + self.private_name: str = private_name + + # data_list + self.chat_history: List[Dict[str, Any]] = [] + self.chat_history_str: str = "" + self.unprocessed_messages: List[Dict[str, Any]] = [] + self.active_users: Set[str] = set() + + # data + self.last_bot_speak_time: Optional[float] = None + self.last_user_speak_time: Optional[float] = None + self.last_message_time: Optional[float] = None + self.last_message_id: Optional[str] = None + self.last_message_content: str = "" + self.last_message_sender: Optional[str] = None + self.bot_id: Optional[str] = None + self.chat_history_count: int = 0 + self.new_messages_count: int = 0 + self.cold_chat_start_time: Optional[float] = None + self.cold_chat_duration: float = 0.0 + + # state + self.is_typing: bool = False + self.is_cold_chat: bool = False + self.changed: bool = False + + # 关联对象 + self.chat_observer: Optional[ChatObserver] = None + + self.handler: ObservationInfoHandler = ObservationInfoHandler(self, self.private_name) + + def bind_to_chat_observer(self, chat_observer: ChatObserver): + """绑定到指定的chat_observer + + Args: + chat_observer: 要绑定的 ChatObserver 实例 + """ + if self.chat_observer: + logger.warning(f"[私聊][{self.private_name}]尝试重复绑定 ChatObserver") + return + + self.chat_observer = chat_observer + try: + if not self.handler: # 确保 handler 已经被创建 + logger.error(f"[私聊][{self.private_name}] 尝试绑定时 handler 未初始化！") + self.chat_observer = None # 重置，防止后续错误 + return + + # 注册关心的通知类型 + self.chat_observer.notification_manager.register_handler( + target="observation_info", notification_type=NotificationType.NEW_MESSAGE, handler=self.handler + ) + self.chat_observer.notification_manager.register_handler( + target="observation_info", notification_type=NotificationType.COLD_CHAT, handler=self.handler + ) + # 可以根据需要注册更多通知类型 + # self.chat_observer.notification_manager.register_handler( + # target="observation_info", notification_type=NotificationType.MESSAGE_DELETED, handler=self.handler + # ) + logger.info(f"[私聊][{self.private_name}]成功绑定到 ChatObserver") + except Exception as e: + logger.error(f"[私聊][{self.private_name}]绑定到 ChatObserver 时出错: {e}") + self.chat_observer = None # 绑定失败，重置 + + def unbind_from_chat_observer(self): + """解除与chat_observer的绑定""" + if ( + self.chat_observer and hasattr(self.chat_observer, "notification_manager") and self.handler + ): # 增加 handler 检查 + try: + self.chat_observer.notification_manager.unregister_handler( + target="observation_info", notification_type=NotificationType.NEW_MESSAGE, handler=self.handler + ) + self.chat_observer.notification_manager.unregister_handler( + target="observation_info", notification_type=NotificationType.COLD_CHAT, handler=self.handler + ) + # 如果注册了其他类型，也要在这里注销 + # self.chat_observer.notification_manager.unregister_handler( + # target="observation_info", notification_type=NotificationType.MESSAGE_DELETED, handler=self.handler + # ) + logger.info(f"[私聊][{self.private_name}]成功从 ChatObserver 解绑") + except Exception as e: + logger.error(f"[私聊][{self.private_name}]从 ChatObserver 解绑时出错: {e}") + finally: # 确保 chat_observer 被重置 + self.chat_observer = None + else: + logger.warning(f"[私聊][{self.private_name}]尝试解绑时 ChatObserver 不存在、无效或 handler 未设置") + + # 修改：update_from_message 接收 UserInfo 对象 + async def update_from_message(self, message: Dict[str, Any], user_info: Optional[UserInfo]): + """从消息更新信息 + + Args: + message: 消息数据字典 + user_info: 解析后的 UserInfo 对象 (可能为 None) + """ + message_time = message.get("time") + message_id = message.get("message_id") + processed_text = message.get("processed_plain_text", "") + + # 只有在新消息到达时才更新 last_message 相关信息 + if message_time and message_time > (self.last_message_time or 0): + self.last_message_time = message_time + self.last_message_id = message_id + self.last_message_content = processed_text + # 重置冷场计时器 + self.is_cold_chat = False + self.cold_chat_start_time = None + self.cold_chat_duration = 0.0 + + if user_info: + sender_id = str(user_info.user_id) # 确保是字符串 + self.last_message_sender = sender_id + # 更新发言时间 + if sender_id == self.bot_id: + self.last_bot_speak_time = message_time + else: + self.last_user_speak_time = message_time + self.active_users.add(sender_id) # 用户发言则认为其活跃 + else: + logger.warning( + f"[私聊][{self.private_name}]处理消息更新时缺少有效的 UserInfo 对象, message_id: {message_id}" + ) + self.last_message_sender = None # 发送者未知 + + # 将原始消息字典添加到未处理列表 + self.unprocessed_messages.append(message) + self.new_messages_count = len(self.unprocessed_messages) # 直接用列表长度 + + # logger.debug(f"[私聊][{self.private_name}]消息更新: last_time={self.last_message_time}, new_count={self.new_messages_count}") + self.update_changed() # 标记状态已改变 + else: + # 如果消息时间戳不是最新的，可能不需要处理，或者记录一个警告 + pass + # logger.warning(f"[私聊][{self.private_name}]收到过时或无效时间戳的消息: ID={message_id}, time={message_time}") + + def update_changed(self): + """标记状态已改变，并重置标记""" + # logger.debug(f"[私聊][{self.private_name}]状态标记为已改变 (changed=True)") + self.changed = True + + async def update_cold_chat_status(self, is_cold: bool, current_time: float): + """更新冷场状态 + + Args: + is_cold: 是否处于冷场状态 + current_time: 当前时间戳 + """ + if is_cold != self.is_cold_chat: # 仅在状态变化时更新 + self.is_cold_chat = is_cold + if is_cold: + # 进入冷场状态 + self.cold_chat_start_time = ( + self.last_message_time or current_time + ) # 从最后消息时间开始算，或从当前时间开始 + logger.info(f"[私聊][{self.private_name}]进入冷场状态，开始时间: {self.cold_chat_start_time}") + else: + # 结束冷场状态 + if self.cold_chat_start_time: + self.cold_chat_duration = current_time - self.cold_chat_start_time + logger.info(f"[私聊][{self.private_name}]结束冷场状态，持续时间: {self.cold_chat_duration:.2f} 秒") + self.cold_chat_start_time = None # 重置开始时间 + self.update_changed() # 状态变化，标记改变 + + # 即使状态没变，如果是冷场状态，也更新持续时间 + if self.is_cold_chat and self.cold_chat_start_time: + self.cold_chat_duration = current_time - self.cold_chat_start_time + + def get_active_duration(self) -> float: + """获取当前活跃时长 (距离最后一条消息的时间) + + Returns: + float: 最后一条消息到现在的时长（秒） + """ + if not self.last_message_time: + return 0.0 + return time.time() - self.last_message_time + + def get_user_response_time(self) -> Optional[float]: + """获取用户最后响应时间 (距离用户最后发言的时间) + + Returns: + Optional[float]: 用户最后发言到现在的时长（秒），如果没有用户发言则返回None + """ + if not self.last_user_speak_time: + return None + return time.time() - self.last_user_speak_time + + def get_bot_response_time(self) -> Optional[float]: + """获取机器人最后响应时间 (距离机器人最后发言的时间) + + Returns: + Optional[float]: 机器人最后发言到现在的时长（秒），如果没有机器人发言则返回None + """ + if not self.last_bot_speak_time: + return None + return time.time() - self.last_bot_speak_time + + async def clear_unprocessed_messages(self): + """将未处理消息移入历史记录，并更新相关状态""" + if not self.unprocessed_messages: + return # 没有未处理消息，直接返回 + + # logger.debug(f"[私聊][{self.private_name}]处理 {len(self.unprocessed_messages)} 条未处理消息...") + # 将未处理消息添加到历史记录中 (确保历史记录有长度限制，避免无限增长) + max_history_len = 100 # 示例：最多保留100条历史记录 + self.chat_history.extend(self.unprocessed_messages) + if len(self.chat_history) > max_history_len: + self.chat_history = self.chat_history[-max_history_len:] + + # 更新历史记录字符串 (只使用最近一部分生成，例如20条) + history_slice_for_str = self.chat_history[-20:] + try: + self.chat_history_str = await build_readable_messages( + history_slice_for_str, + replace_bot_name=True, + merge_messages=False, + timestamp_mode="relative", + read_mark=0.0, # read_mark 可能需要根据逻辑调整 + ) + except Exception as e: + logger.error(f"[私聊][{self.private_name}]构建聊天记录字符串时出错: {e}") + self.chat_history_str = "[构建聊天记录出错]" # 提供错误提示 + + # 清空未处理消息列表和计数 + # cleared_count = len(self.unprocessed_messages) + self.unprocessed_messages.clear() + self.new_messages_count = 0 + # self.has_unread_messages = False # 这个状态可以通过 new_messages_count 判断 + + self.chat_history_count = len(self.chat_history) # 更新历史记录总数 + # logger.debug(f"[私聊][{self.private_name}]已处理 {cleared_count} 条消息，当前历史记录 {self.chat_history_count} 条。") + + self.update_changed() # 状态改变 diff --git a/src/chat/brain_chat/PFC/pfc.py b/src/chat/brain_chat/PFC/pfc.py new file mode 100644 index 00000000..b17ee21d --- /dev/null +++ b/src/chat/brain_chat/PFC/pfc.py @@ -0,0 +1,345 @@ +from typing import List, Tuple, TYPE_CHECKING +from src.common.logger import get_module_logger +from ..models.utils_model import LLMRequest +from ...config.config import global_config +from .chat_observer import ChatObserver +from .pfc_utils import get_items_from_json +from src.individuality.individuality import Individuality +from .conversation_info import ConversationInfo +from .observation_info import ObservationInfo +from src.plugins.utils.chat_message_builder import build_readable_messages +from rich.traceback import install + +install(extra_lines=3) + +if TYPE_CHECKING: + pass + +logger = get_module_logger("pfc") + + +def _calculate_similarity(goal1: str, goal2: str) -> float: + """简单计算两个目标之间的相似度 + + 这里使用一个简单的实现，实际可以使用更复杂的文本相似度算法 + + Args: + goal1: 第一个目标 + goal2: 第二个目标 + + Returns: + float: 相似度得分 (0-1) + """ + # 简单实现：检查重叠字数比例 + words1 = set(goal1) + words2 = set(goal2) + overlap = len(words1.intersection(words2)) + total = len(words1.union(words2)) + return overlap / total if total > 0 else 0 + + +class GoalAnalyzer: + """对话目标分析器""" + + def __init__(self, stream_id: str, private_name: str): + self.llm = LLMRequest( + model=global_config.llm_normal, temperature=0.7, max_tokens=1000, request_type="conversation_goal" + ) + + self.personality_info = Individuality.get_instance().get_prompt(x_person=2, level=3) + self.name = global_config.BOT_NICKNAME + self.nick_name = global_config.BOT_ALIAS_NAMES + self.private_name = private_name + self.chat_observer = ChatObserver.get_instance(stream_id, private_name) + + # 多目标存储结构 + self.goals = [] # 存储多个目标 + self.max_goals = 3 # 同时保持的最大目标数量 + self.current_goal_and_reason = None + + async def analyze_goal(self, conversation_info: ConversationInfo, observation_info: ObservationInfo): + """分析对话历史并设定目标 + + Args: + conversation_info: 对话信息 + observation_info: 观察信息 + + Returns: + Tuple[str, str, str]: (目标, 方法, 原因) + """ + # 构建对话目标 + goals_str = "" + if conversation_info.goal_list: + for goal_reason in conversation_info.goal_list: + if isinstance(goal_reason, dict): + goal = goal_reason.get("goal", "目标内容缺失") + reasoning = goal_reason.get("reasoning", "没有明确原因") + else: + goal = str(goal_reason) + reasoning = "没有明确原因" + + goal_str = f"目标：{goal}，产生该对话目标的原因：{reasoning}\n" + goals_str += goal_str + else: + goal = "目前没有明确对话目标" + reasoning = "目前没有明确对话目标，最好思考一个对话目标" + goals_str = f"目标：{goal}，产生该对话目标的原因：{reasoning}\n" + + # 获取聊天历史记录 + chat_history_text = observation_info.chat_history_str + + if observation_info.new_messages_count > 0: + new_messages_list = observation_info.unprocessed_messages + new_messages_str = await build_readable_messages( + new_messages_list, + replace_bot_name=True, + merge_messages=False, + timestamp_mode="relative", + read_mark=0.0, + ) + chat_history_text += f"\n--- 以下是 {observation_info.new_messages_count} 条新消息 ---\n{new_messages_str}" + + # await observation_info.clear_unprocessed_messages() + + persona_text = f"你的名字是{self.name}，{self.personality_info}。" + # 构建action历史文本 + action_history_list = conversation_info.done_action + action_history_text = "你之前做的事情是：" + for action in action_history_list: + action_history_text += f"{action}\n" + + prompt = f"""{persona_text}。现在你在参与一场QQ聊天，请分析以下聊天记录，并根据你的性格特征确定多个明确的对话目标。 +这些目标应该反映出对话的不同方面和意图。 + +{action_history_text} +当前对话目标： +{goals_str} + +聊天记录： +{chat_history_text} + +请分析当前对话并确定最适合的对话目标。你可以： +1. 保持现有目标不变 +2. 修改现有目标 +3. 添加新目标 +4. 删除不再相关的目标 +5. 如果你想结束对话，请设置一个目标，目标goal为"结束对话"，原因reasoning为你希望结束对话 + +请以JSON数组格式输出当前的所有对话目标，每个目标包含以下字段： +1. goal: 对话目标（简短的一句话） +2. reasoning: 对话原因，为什么设定这个目标（简要解释） + +输出格式示例： +[ +{{ + "goal": "回答用户关于Python编程的具体问题", + "reasoning": "用户提出了关于Python的技术问题，需要专业且准确的解答" +}}, +{{ + "goal": "回答用户关于python安装的具体问题", + "reasoning": "用户提出了关于Python的技术问题，需要专业且准确的解答" +}} +]""" + + logger.debug(f"[私聊][{self.private_name}]发送到LLM的提示词: {prompt}") + try: + content, _ = await self.llm.generate_response_async(prompt) + logger.debug(f"[私聊][{self.private_name}]LLM原始返回内容: {content}") + except Exception as e: + logger.error(f"[私聊][{self.private_name}]分析对话目标时出错: {str(e)}") + content = "" + + # 使用改进后的get_items_from_json函数处理JSON数组 + success, result = get_items_from_json( + content, + self.private_name, + "goal", + "reasoning", + required_types={"goal": str, "reasoning": str}, + allow_array=True, + ) + + if success: + # 判断结果是单个字典还是字典列表 + if isinstance(result, list): + # 清空现有目标列表并添加新目标 + conversation_info.goal_list = [] + for item in result: + conversation_info.goal_list.append(item) + + # 返回第一个目标作为当前主要目标（如果有） + if result: + first_goal = result[0] + return first_goal.get("goal", ""), "", first_goal.get("reasoning", "") + else: + # 单个目标的情况 + conversation_info.goal_list.append(result) + return goal, "", reasoning + + # 如果解析失败，返回默认值 + return "", "", "" + + async def _update_goals(self, new_goal: str, method: str, reasoning: str): + """更新目标列表 + + Args: + new_goal: 新的目标 + method: 实现目标的方法 + reasoning: 目标的原因 + """ + # 检查新目标是否与现有目标相似 + for i, (existing_goal, _, _) in enumerate(self.goals): + if _calculate_similarity(new_goal, existing_goal) > 0.7: # 相似度阈值 + # 更新现有目标 + self.goals[i] = (new_goal, method, reasoning) + # 将此目标移到列表前面（最主要的位置） + self.goals.insert(0, self.goals.pop(i)) + return + + # 添加新目标到列表前面 + self.goals.insert(0, (new_goal, method, reasoning)) + + # 限制目标数量 + if len(self.goals) > self.max_goals: + self.goals.pop() # 移除最老的目标 + + async def get_all_goals(self) -> List[Tuple[str, str, str]]: + """获取所有当前目标 + + Returns: + List[Tuple[str, str, str]]: 目标列表，每项为(目标, 方法, 原因) + """ + return self.goals.copy() + + async def get_alternative_goals(self) -> List[Tuple[str, str, str]]: + """获取除了当前主要目标外的其他备选目标 + + Returns: + List[Tuple[str, str, str]]: 备选目标列表 + """ + if len(self.goals) <= 1: + return [] + return self.goals[1:].copy() + + async def analyze_conversation(self, goal, reasoning): + messages = self.chat_observer.get_cached_messages() + chat_history_text = await build_readable_messages( + messages, + replace_bot_name=True, + merge_messages=False, + timestamp_mode="relative", + read_mark=0.0, + ) + + persona_text = f"你的名字是{self.name}，{self.personality_info}。" + # ===> Persona 文本构建结束 <=== + + # --- 修改 Prompt 字符串，使用 persona_text --- + prompt = f"""{persona_text}。现在你在参与一场QQ聊天， + 当前对话目标：{goal} + 产生该对话目标的原因：{reasoning} + + 请分析以下聊天记录，并根据你的性格特征评估该目标是否已经达到，或者你是否希望停止该次对话。 + 聊天记录： + {chat_history_text} + 请以JSON格式输出，包含以下字段： + 1. goal_achieved: 对话目标是否已经达到（true/false） + 2. stop_conversation: 是否希望停止该次对话（true/false） + 3. reason: 为什么希望停止该次对话（简要解释） + +输出格式示例： +{{ + "goal_achieved": true, + "stop_conversation": false, + "reason": "虽然目标已达成，但对话仍然有继续的价值" +}}""" + + try: + content, _ = await self.llm.generate_response_async(prompt) + logger.debug(f"[私聊][{self.private_name}]LLM原始返回内容: {content}") + + # 尝试解析JSON + success, result = get_items_from_json( + content, + self.private_name, + "goal_achieved", + "stop_conversation", + "reason", + required_types={"goal_achieved": bool, "stop_conversation": bool, "reason": str}, + ) + + if not success: + logger.error(f"[私聊][{self.private_name}]无法解析对话分析结果JSON") + return False, False, "解析结果失败" + + goal_achieved = result["goal_achieved"] + stop_conversation = result["stop_conversation"] + reason = result["reason"] + + return goal_achieved, stop_conversation, reason + + except Exception as e: + logger.error(f"[私聊][{self.private_name}]分析对话状态时出错: {str(e)}") + return False, False, f"分析出错: {str(e)}" + + +# 先注释掉，万一以后出问题了还能开回来（（（ +# class DirectMessageSender: +# """直接发送消息到平台的发送器""" + +# def __init__(self, private_name: str): +# self.logger = get_module_logger("direct_sender") +# self.storage = MessageStorage() +# self.private_name = private_name + +# async def send_via_ws(self, message: MessageSending) -> None: +# try: +# await global_api.send_message(message) +# except Exception as e: +# raise ValueError(f"未找到平台：{message.message_info.platform} 的url配置，请检查配置文件") from e + +# async def send_message( +# self, +# chat_stream: ChatStream, +# content: str, +# reply_to_message: Optional[Message] = None, +# ) -> None: +# """直接发送消息到平台 + +# Args: +# chat_stream: 聊天流 +# content: 消息内容 +# reply_to_message: 要回复的消息 +# """ +# # 构建消息对象 +# message_segment = Seg(type="text", data=content) +# bot_user_info = UserInfo( +# user_id=global_config.BOT_QQ, +# user_nickname=global_config.BOT_NICKNAME, +# platform=chat_stream.platform, +# ) + +# message = MessageSending( +# message_id=f"dm{round(time.time(), 2)}", +# chat_stream=chat_stream, +# bot_user_info=bot_user_info, +# sender_info=reply_to_message.message_info.user_info if reply_to_message else None, +# message_segment=message_segment, +# reply=reply_to_message, +# is_head=True, +# is_emoji=False, +# thinking_start_time=time.time(), +# ) + +# # 处理消息 +# await message.process() + +# _message_json = message.to_dict() + +# # 发送消息 +# try: +# await self.send_via_ws(message) +# await self.storage.store_message(message, chat_stream) +# logger.success(f"[私聊][{self.private_name}]PFC消息已发送: {content}") +# except Exception as e: +# logger.error(f"[私聊][{self.private_name}]PFC消息发送失败: {str(e)}") diff --git a/src/chat/brain_chat/PFC/pfc_KnowledgeFetcher.py b/src/chat/brain_chat/PFC/pfc_KnowledgeFetcher.py new file mode 100644 index 00000000..0989339d --- /dev/null +++ b/src/chat/brain_chat/PFC/pfc_KnowledgeFetcher.py @@ -0,0 +1,85 @@ +from typing import List, Tuple +from src.common.logger import get_module_logger +from src.plugins.memory_system.Hippocampus import HippocampusManager +from ..models.utils_model import LLMRequest +from ...config.config import global_config +from ..chat.message import Message +from ..knowledge.knowledge_lib import qa_manager +from ..utils.chat_message_builder import build_readable_messages + +logger = get_module_logger("knowledge_fetcher") + + +class KnowledgeFetcher: + """知识调取器""" + + def __init__(self, private_name: str): + self.llm = LLMRequest( + model=global_config.llm_normal, + temperature=global_config.llm_normal["temp"], + max_tokens=1000, + request_type="knowledge_fetch", + ) + self.private_name = private_name + + def _lpmm_get_knowledge(self, query: str) -> str: + """获取相关知识 + + Args: + query: 查询内容 + + Returns: + str: 构造好的,带相关度的知识 + """ + + logger.debug(f"[私聊][{self.private_name}]正在从LPMM知识库中获取知识") + try: + knowledge_info = qa_manager.get_knowledge(query) + logger.debug(f"[私聊][{self.private_name}]LPMM知识库查询结果: {knowledge_info:150}") + return knowledge_info + except Exception as e: + logger.error(f"[私聊][{self.private_name}]LPMM知识库搜索工具执行失败: {str(e)}") + return "未找到匹配的知识" + + async def fetch(self, query: str, chat_history: List[Message]) -> Tuple[str, str]: + """获取相关知识 + + Args: + query: 查询内容 + chat_history: 聊天历史 + + Returns: + Tuple[str, str]: (获取的知识, 知识来源) + """ + # 构建查询上下文 + chat_history_text = await build_readable_messages( + chat_history, + replace_bot_name=True, + merge_messages=False, + timestamp_mode="relative", + read_mark=0.0, + ) + + # 从记忆中获取相关知识 + related_memory = await HippocampusManager.get_instance().get_memory_from_text( + text=f"{query}\n{chat_history_text}", + max_memory_num=3, + max_memory_length=2, + max_depth=3, + fast_retrieval=False, + ) + knowledge_text = "" + sources_text = "无记忆匹配" # 默认值 + if related_memory: + sources = [] + for memory in related_memory: + knowledge_text += memory[1] + "\n" + sources.append(f"记忆片段{memory[0]}") + knowledge_text = knowledge_text.strip() + sources_text = "，".join(sources) + + knowledge_text += "\n现在有以下**知识**可供参考：\n " + knowledge_text += self._lpmm_get_knowledge(query) + knowledge_text += "\n请记住这些**知识**，并根据**知识**回答问题。\n" + + return knowledge_text or "未找到相关知识", sources_text or "无记忆匹配" diff --git a/src/chat/brain_chat/PFC/pfc_manager.py b/src/chat/brain_chat/PFC/pfc_manager.py new file mode 100644 index 00000000..7837606c --- /dev/null +++ b/src/chat/brain_chat/PFC/pfc_manager.py @@ -0,0 +1,115 @@ +import time +from typing import Dict, Optional +from src.common.logger import get_module_logger +from .conversation import Conversation +import traceback + +logger = get_module_logger("pfc_manager") + + +class PFCManager: + """PFC对话管理器，负责管理所有对话实例""" + + # 单例模式 + _instance = None + + # 会话实例管理 + _instances: Dict[str, Conversation] = {} + _initializing: Dict[str, bool] = {} + + @classmethod + def get_instance(cls) -> "PFCManager": + """获取管理器单例 + + Returns: + PFCManager: 管理器实例 + """ + if cls._instance is None: + cls._instance = PFCManager() + return cls._instance + + async def get_or_create_conversation(self, stream_id: str, private_name: str) -> Optional[Conversation]: + """获取或创建对话实例 + + Args: + stream_id: 聊天流ID + private_name: 私聊名称 + + Returns: + Optional[Conversation]: 对话实例，创建失败则返回None + """ + # 检查是否已经有实例 + if stream_id in self._initializing and self._initializing[stream_id]: + logger.debug(f"[私聊][{private_name}]会话实例正在初始化中: {stream_id}") + return None + + if stream_id in self._instances and self._instances[stream_id].should_continue: + logger.debug(f"[私聊][{private_name}]使用现有会话实例: {stream_id}") + return self._instances[stream_id] + if stream_id in self._instances: + instance = self._instances[stream_id] + if ( + hasattr(instance, "ignore_until_timestamp") + and instance.ignore_until_timestamp + and time.time() < instance.ignore_until_timestamp + ): + logger.debug(f"[私聊][{private_name}]会话实例当前处于忽略状态: {stream_id}") + # 返回 None 阻止交互。或者可以返回实例但标记它被忽略了喵？ + # 还是返回 None 吧喵。 + return None + + # 检查 should_continue 状态 + if instance.should_continue: + logger.debug(f"[私聊][{private_name}]使用现有会话实例: {stream_id}") + return instance + # else: 实例存在但不应继续 + try: + # 创建新实例 + logger.info(f"[私聊][{private_name}]创建新的对话实例: {stream_id}") + self._initializing[stream_id] = True + # 创建实例 + conversation_instance = Conversation(stream_id, private_name) + self._instances[stream_id] = conversation_instance + + # 启动实例初始化 + await self._initialize_conversation(conversation_instance) + except Exception as e: + logger.error(f"[私聊][{private_name}]创建会话实例失败: {stream_id}, 错误: {e}") + return None + + return conversation_instance + + async def _initialize_conversation(self, conversation: Conversation): + """初始化会话实例 + + Args: + conversation: 要初始化的会话实例 + """ + stream_id = conversation.stream_id + private_name = conversation.private_name + + try: + logger.info(f"[私聊][{private_name}]开始初始化会话实例: {stream_id}") + # 启动初始化流程 + await conversation._initialize() + + # 标记初始化完成 + self._initializing[stream_id] = False + + logger.info(f"[私聊][{private_name}]会话实例 {stream_id} 初始化完成") + + except Exception as e: + logger.error(f"[私聊][{private_name}]管理器初始化会话实例失败: {stream_id}, 错误: {e}") + logger.error(f"[私聊][{private_name}]{traceback.format_exc()}") + # 清理失败的初始化 + + async def get_conversation(self, stream_id: str) -> Optional[Conversation]: + """获取已存在的会话实例 + + Args: + stream_id: 聊天流ID + + Returns: + Optional[Conversation]: 会话实例，不存在则返回None + """ + return self._instances.get(stream_id) diff --git a/src/chat/brain_chat/PFC/pfc_types.py b/src/chat/brain_chat/PFC/pfc_types.py new file mode 100644 index 00000000..0ea5eda6 --- /dev/null +++ b/src/chat/brain_chat/PFC/pfc_types.py @@ -0,0 +1,23 @@ +from enum import Enum +from typing import Literal + + +class ConversationState(Enum): + """对话状态""" + + INIT = "初始化" + RETHINKING = "重新思考" + ANALYZING = "分析历史" + PLANNING = "规划目标" + GENERATING = "生成回复" + CHECKING = "检查回复" + SENDING = "发送消息" + FETCHING = "获取知识" + WAITING = "等待" + LISTENING = "倾听" + ENDED = "结束" + JUDGING = "判断" + IGNORED = "屏蔽" + + +ActionType = Literal["direct_reply", "fetch_knowledge", "wait"] diff --git a/src/chat/brain_chat/PFC/pfc_utils.py b/src/chat/brain_chat/PFC/pfc_utils.py new file mode 100644 index 00000000..2f7bd5e0 --- /dev/null +++ b/src/chat/brain_chat/PFC/pfc_utils.py @@ -0,0 +1,127 @@ +import json +import re +from typing import Dict, Any, Optional, Tuple, List, Union +from src.common.logger import get_module_logger + +logger = get_module_logger("pfc_utils") + + +def get_items_from_json( + content: str, + private_name: str, + *items: str, + default_values: Optional[Dict[str, Any]] = None, + required_types: Optional[Dict[str, type]] = None, + allow_array: bool = True, +) -> Tuple[bool, Union[Dict[str, Any], List[Dict[str, Any]]]]: + """从文本中提取JSON内容并获取指定字段 + + Args: + content: 包含JSON的文本 + private_name: 私聊名称 + *items: 要提取的字段名 + default_values: 字段的默认值，格式为 {字段名: 默认值} + required_types: 字段的必需类型，格式为 {字段名: 类型} + allow_array: 是否允许解析JSON数组 + + Returns: + Tuple[bool, Union[Dict[str, Any], List[Dict[str, Any]]]]: (是否成功, 提取的字段字典或字典列表) + """ + content = content.strip() + result = {} + + # 设置默认值 + if default_values: + result.update(default_values) + + # 首先尝试解析为JSON数组 + if allow_array: + try: + # 尝试找到文本中的JSON数组 + array_pattern = r"\[[\s\S]*\]" + array_match = re.search(array_pattern, content) + if array_match: + array_content = array_match.group() + json_array = json.loads(array_content) + + # 确认是数组类型 + if isinstance(json_array, list): + # 验证数组中的每个项目是否包含所有必需字段 + valid_items = [] + for item in json_array: + if not isinstance(item, dict): + continue + + # 检查是否有所有必需字段 + if all(field in item for field in items): + # 验证字段类型 + if required_types: + type_valid = True + for field, expected_type in required_types.items(): + if field in item and not isinstance(item[field], expected_type): + type_valid = False + break + + if not type_valid: + continue + + # 验证字符串字段不为空 + string_valid = True + for field in items: + if isinstance(item[field], str) and not item[field].strip(): + string_valid = False + break + + if not string_valid: + continue + + valid_items.append(item) + + if valid_items: + return True, valid_items + except json.JSONDecodeError: + logger.debug(f"[私聊][{private_name}]JSON数组解析失败，尝试解析单个JSON对象") + except Exception as e: + logger.debug(f"[私聊][{private_name}]尝试解析JSON数组时出错: {str(e)}") + + # 尝试解析JSON对象 + try: + json_data = json.loads(content) + except json.JSONDecodeError: + # 如果直接解析失败，尝试查找和提取JSON部分 + json_pattern = r"\{[^{}]*\}" + json_match = re.search(json_pattern, content) + if json_match: + try: + json_data = json.loads(json_match.group()) + except json.JSONDecodeError: + logger.error(f"[私聊][{private_name}]提取的JSON内容解析失败") + return False, result + else: + logger.error(f"[私聊][{private_name}]无法在返回内容中找到有效的JSON") + return False, result + + # 提取字段 + for item in items: + if item in json_data: + result[item] = json_data[item] + + # 验证必需字段 + if not all(item in result for item in items): + logger.error(f"[私聊][{private_name}]JSON缺少必要字段，实际内容: {json_data}") + return False, result + + # 验证字段类型 + if required_types: + for field, expected_type in required_types.items(): + if field in result and not isinstance(result[field], expected_type): + logger.error(f"[私聊][{private_name}]{field} 必须是 {expected_type.__name__} 类型") + return False, result + + # 验证字符串字段不为空 + for field in items: + if isinstance(result[field], str) and not result[field].strip(): + logger.error(f"[私聊][{private_name}]{field} 不能为空") + return False, result + + return True, result diff --git a/src/chat/brain_chat/PFC/reply_checker.py b/src/chat/brain_chat/PFC/reply_checker.py new file mode 100644 index 00000000..35e9af50 --- /dev/null +++ b/src/chat/brain_chat/PFC/reply_checker.py @@ -0,0 +1,183 @@ +import json +from typing import Tuple, List, Dict, Any +from src.common.logger import get_module_logger +from ..models.utils_model import LLMRequest +from ...config.config import global_config +from .chat_observer import ChatObserver +from maim_message import UserInfo + +logger = get_module_logger("reply_checker") + + +class ReplyChecker: + """回复检查器""" + + def __init__(self, stream_id: str, private_name: str): + self.llm = LLMRequest( + model=global_config.llm_PFC_reply_checker, temperature=0.50, max_tokens=1000, request_type="reply_check" + ) + self.name = global_config.BOT_NICKNAME + self.private_name = private_name + self.chat_observer = ChatObserver.get_instance(stream_id, private_name) + self.max_retries = 3 # 最大重试次数 + + async def check( + self, reply: str, goal: str, chat_history: List[Dict[str, Any]], chat_history_text: str, retry_count: int = 0 + ) -> Tuple[bool, str, bool]: + """检查生成的回复是否合适 + + Args: + reply: 生成的回复 + goal: 对话目标 + chat_history: 对话历史记录 + chat_history_text: 对话历史记录文本 + retry_count: 当前重试次数 + + Returns: + Tuple[bool, str, bool]: (是否合适, 原因, 是否需要重新规划) + """ + # 不再从 observer 获取，直接使用传入的 chat_history + # messages = self.chat_observer.get_cached_messages(limit=20) + try: + # 筛选出最近由 Bot 自己发送的消息 + bot_messages = [] + for msg in reversed(chat_history): + user_info = UserInfo.from_dict(msg.get("user_info", {})) + if str(user_info.user_id) == str(global_config.BOT_QQ): # 确保比较的是字符串 + bot_messages.append(msg.get("processed_plain_text", "")) + if len(bot_messages) >= 2: # 只和最近的两条比较 + break + # 进行比较 + if bot_messages: + # 可以用简单比较，或者更复杂的相似度库 (如 difflib) + # 简单比较：是否完全相同 + if reply == bot_messages[0]: # 和最近一条完全一样 + logger.warning( + f"[私聊][{self.private_name}]ReplyChecker 检测到回复与上一条 Bot 消息完全相同: '{reply}'" + ) + return ( + False, + "被逻辑检查拒绝：回复内容与你上一条发言完全相同，可以选择深入话题或寻找其它话题或等待", + True, + ) # 不合适，需要返回至决策层 + # 2. 相似度检查 (如果精确匹配未通过) + import difflib # 导入 difflib 库 + + # 计算编辑距离相似度，ratio() 返回 0 到 1 之间的浮点数 + similarity_ratio = difflib.SequenceMatcher(None, reply, bot_messages[0]).ratio() + logger.debug(f"[私聊][{self.private_name}]ReplyChecker - 相似度: {similarity_ratio:.2f}") + + # 设置一个相似度阈值 + similarity_threshold = 0.9 + if similarity_ratio > similarity_threshold: + logger.warning( + f"[私聊][{self.private_name}]ReplyChecker 检测到回复与上一条 Bot 消息高度相似 (相似度 {similarity_ratio:.2f}): '{reply}'" + ) + return ( + False, + f"被逻辑检查拒绝：回复内容与你上一条发言高度相似 (相似度 {similarity_ratio:.2f})，可以选择深入话题或寻找其它话题或等待。", + True, + ) + + except Exception as e: + import traceback + + logger.error(f"[私聊][{self.private_name}]检查回复时出错: 类型={type(e)}, 值={e}") + logger.error(f"[私聊][{self.private_name}]{traceback.format_exc()}") # 打印详细的回溯信息 + + prompt = f"""你是一个聊天逻辑检查器，请检查以下回复或消息是否合适： + +当前对话目标：{goal} +最新的对话记录： +{chat_history_text} + +待检查的消息： +{reply} + +请结合聊天记录检查以下几点： +1. 这条消息是否依然符合当前对话目标和实现方式 +2. 这条消息是否与最新的对话记录保持一致性 +3. 是否存在重复发言，或重复表达同质内容（尤其是只是换一种方式表达了相同的含义） +4. 这条消息是否包含违规内容（例如血腥暴力，政治敏感等） +5. 这条消息是否以发送者的角度发言（不要让发送者自己回复自己的消息） +6. 这条消息是否通俗易懂 +7. 这条消息是否有些多余，例如在对方没有回复的情况下，依然连续多次“消息轰炸”（尤其是已经连续发送3条信息的情况，这很可能不合理，需要着重判断） +8. 这条消息是否使用了完全没必要的修辞 +9. 这条消息是否逻辑通顺 +10. 这条消息是否太过冗长了（通常私聊的每条消息长度在20字以内，除非特殊情况） +11. 在连续多次发送消息的情况下，这条消息是否衔接自然，会不会显得奇怪（例如连续两条消息中部分内容重叠） + +请以JSON格式输出，包含以下字段： +1. suitable: 是否合适 (true/false) +2. reason: 原因说明 +3. need_replan: 是否需要重新决策 (true/false)，当你认为此时已经不适合发消息，需要规划其它行动时，设为true + +输出格式示例： +{{ + "suitable": true, + "reason": "回复符合要求，虽然有可能略微偏离目标，但是整体内容流畅得体", + "need_replan": false +}} + +注意：请严格按照JSON格式输出，不要包含任何其他内容。""" + + try: + content, _ = await self.llm.generate_response_async(prompt) + logger.debug(f"[私聊][{self.private_name}]检查回复的原始返回: {content}") + + # 清理内容，尝试提取JSON部分 + content = content.strip() + try: + # 尝试直接解析 + result = json.loads(content) + except json.JSONDecodeError: + # 如果直接解析失败，尝试查找和提取JSON部分 + import re + + json_pattern = r"\{[^{}]*\}" + json_match = re.search(json_pattern, content) + if json_match: + try: + result = json.loads(json_match.group()) + except json.JSONDecodeError: + # 如果JSON解析失败，尝试从文本中提取结果 + is_suitable = "不合适" not in content.lower() and "违规" not in content.lower() + reason = content[:100] if content else "无法解析响应" + need_replan = "重新规划" in content.lower() or "目标不适合" in content.lower() + return is_suitable, reason, need_replan + else: + # 如果找不到JSON，从文本中判断 + is_suitable = "不合适" not in content.lower() and "违规" not in content.lower() + reason = content[:100] if content else "无法解析响应" + need_replan = "重新规划" in content.lower() or "目标不适合" in content.lower() + return is_suitable, reason, need_replan + + # 验证JSON字段 + suitable = result.get("suitable", None) + reason = result.get("reason", "未提供原因") + need_replan = result.get("need_replan", False) + + # 如果suitable字段是字符串，转换为布尔值 + if isinstance(suitable, str): + suitable = suitable.lower() == "true" + + # 如果suitable字段不存在或不是布尔值，从reason中判断 + if suitable is None: + suitable = "不合适" not in reason.lower() and "违规" not in reason.lower() + + # 如果不合适且未达到最大重试次数，返回需要重试 + if not suitable and retry_count < self.max_retries: + return False, reason, False + + # 如果不合适且已达到最大重试次数，返回需要重新规划 + if not suitable and retry_count >= self.max_retries: + return False, f"多次重试后仍不合适: {reason}", True + + return suitable, reason, need_replan + + except Exception as e: + logger.error(f"[私聊][{self.private_name}]检查回复时出错: {e}") + # 如果出错且已达到最大重试次数，建议重新规划 + if retry_count >= self.max_retries: + return False, "多次检查失败，建议重新规划", True + return False, f"检查过程出错，建议重试: {str(e)}", False diff --git a/src/chat/brain_chat/PFC/reply_generator.py b/src/chat/brain_chat/PFC/reply_generator.py new file mode 100644 index 00000000..890f807c --- /dev/null +++ b/src/chat/brain_chat/PFC/reply_generator.py @@ -0,0 +1,228 @@ +from typing import Tuple, List, Dict, Any +from src.common.logger import get_module_logger +from ..models.utils_model import LLMRequest +from ...config.config import global_config +from .chat_observer import ChatObserver +from .reply_checker import ReplyChecker +from src.individuality.individuality import Individuality +from .observation_info import ObservationInfo +from .conversation_info import ConversationInfo +from src.plugins.utils.chat_message_builder import build_readable_messages + +logger = get_module_logger("reply_generator") + +# --- 定义 Prompt 模板 --- + +# Prompt for direct_reply (首次回复) +PROMPT_DIRECT_REPLY = """{persona_text}。现在你在参与一场QQ私聊，请根据以下信息生成一条回复： + +当前对话目标：{goals_str} + +{knowledge_info_str} + +最近的聊天记录： +{chat_history_text} + + +请根据上述信息，结合聊天记录，回复对方。该回复应该： +1. 符合对话目标，以"你"的角度发言（不要自己与自己对话！） +2. 符合你的性格特征和身份细节 +3. 通俗易懂，自然流畅，像正常聊天一样，简短（通常20字以内，除非特殊情况） +4. 可以适当利用相关知识，但不要生硬引用 +5. 自然、得体，结合聊天记录逻辑合理，且没有重复表达同质内容 + +请注意把握聊天内容，不要回复的太有条理，可以有个性。请分清"你"和对方说的话，不要把"你"说的话当做对方说的话，这是你自己说的话。 +可以回复得自然随意自然一些，就像真人一样，注意把握聊天内容，整体风格可以平和、简短，不要刻意突出自身学科背景，不要说你说过的话，可以简短，多简短都可以，但是避免冗长。 +请你注意不要输出多余内容(包括前后缀，冒号和引号，括号，表情等)，只输出回复内容。 +不要输出多余内容(包括前后缀，冒号和引号，括号，表情包，at或 @等 )。 + +请直接输出回复内容，不需要任何额外格式。""" + +# Prompt for send_new_message (追问/补充) +PROMPT_SEND_NEW_MESSAGE = """{persona_text}。现在你在参与一场QQ私聊，**刚刚你已经发送了一条或多条消息**，现在请根据以下信息再发一条新消息： + +当前对话目标：{goals_str} + +{knowledge_info_str} + +最近的聊天记录： +{chat_history_text} + + +请根据上述信息，结合聊天记录，继续发一条新消息（例如对之前消息的补充，深入话题，或追问等等）。该消息应该： +1. 符合对话目标，以"你"的角度发言（不要自己与自己对话！） +2. 符合你的性格特征和身份细节 +3. 通俗易懂，自然流畅，像正常聊天一样，简短（通常20字以内，除非特殊情况） +4. 可以适当利用相关知识，但不要生硬引用 +5. 跟之前你发的消息自然的衔接，逻辑合理，且没有重复表达同质内容或部分重叠内容 + +请注意把握聊天内容，不用太有条理，可以有个性。请分清"你"和对方说的话，不要把"你"说的话当做对方说的话，这是你自己说的话。 +这条消息可以自然随意自然一些，就像真人一样，注意把握聊天内容，整体风格可以平和、简短，不要刻意突出自身学科背景，不要说你说过的话，可以简短，多简短都可以，但是避免冗长。 +请你注意不要输出多余内容(包括前后缀，冒号和引号，括号，表情等)，只输出消息内容。 +不要输出多余内容(包括前后缀，冒号和引号，括号，表情包，at或 @等 )。 + +请直接输出回复内容，不需要任何额外格式。""" + +# Prompt for say_goodbye (告别语生成) +PROMPT_FAREWELL = """{persona_text}。你在参与一场 QQ 私聊，现在对话似乎已经结束，你决定再发一条最后的消息来圆满结束。 + +最近的聊天记录： +{chat_history_text} + +请根据上述信息，结合聊天记录，构思一条**简短、自然、符合你人设**的最后的消息。 +这条消息应该： +1. 从你自己的角度发言。 +2. 符合你的性格特征和身份细节。 +3. 通俗易懂，自然流畅，通常很简短。 +4. 自然地为这场对话画上句号，避免开启新话题或显得冗长、刻意。 + +请像真人一样随意自然，**简洁是关键**。 +不要输出多余内容（包括前后缀、冒号、引号、括号、表情包、at或@等）。 + +请直接输出最终的告别消息内容，不需要任何额外格式。""" + + +class ReplyGenerator: + """回复生成器""" + + def __init__(self, stream_id: str, private_name: str): + self.llm = LLMRequest( + model=global_config.llm_PFC_chat, + temperature=global_config.llm_PFC_chat["temp"], + max_tokens=300, + request_type="reply_generation", + ) + self.personality_info = Individuality.get_instance().get_prompt(x_person=2, level=3) + self.name = global_config.BOT_NICKNAME + self.private_name = private_name + self.chat_observer = ChatObserver.get_instance(stream_id, private_name) + self.reply_checker = ReplyChecker(stream_id, private_name) + + # 修改 generate 方法签名，增加 action_type 参数 + async def generate( + self, observation_info: ObservationInfo, conversation_info: ConversationInfo, action_type: str + ) -> str: + """生成回复 + + Args: + observation_info: 观察信息 + conversation_info: 对话信息 + action_type: 当前执行的动作类型 ('direct_reply' 或 'send_new_message') + + Returns: + str: 生成的回复 + """ + # 构建提示词 + logger.debug( + f"[私聊][{self.private_name}]开始生成回复 (动作类型: {action_type})：当前目标: {conversation_info.goal_list}" + ) + + # --- 构建通用 Prompt 参数 --- + # (这部分逻辑基本不变) + + # 构建对话目标 (goals_str) + goals_str = "" + if conversation_info.goal_list: + for goal_reason in conversation_info.goal_list: + if isinstance(goal_reason, dict): + goal = goal_reason.get("goal", "目标内容缺失") + reasoning = goal_reason.get("reasoning", "没有明确原因") + else: + goal = str(goal_reason) + reasoning = "没有明确原因" + + goal = str(goal) if goal is not None else "目标内容缺失" + reasoning = str(reasoning) if reasoning is not None else "没有明确原因" + goals_str += f"- 目标：{goal}\n 原因：{reasoning}\n" + else: + goals_str = "- 目前没有明确对话目标\n" # 简化无目标情况 + + # --- 新增：构建知识信息字符串 --- + knowledge_info_str = "【供参考的相关知识和记忆】\n" # 稍微改下标题，表明是供参考 + try: + # 检查 conversation_info 是否有 knowledge_list 并且不为空 + if hasattr(conversation_info, "knowledge_list") and conversation_info.knowledge_list: + # 最多只显示最近的 5 条知识 + recent_knowledge = conversation_info.knowledge_list[-5:] + for i, knowledge_item in enumerate(recent_knowledge): + if isinstance(knowledge_item, dict): + query = knowledge_item.get("query", "未知查询") + knowledge = knowledge_item.get("knowledge", "无知识内容") + source = knowledge_item.get("source", "未知来源") + # 只取知识内容的前 2000 个字 + knowledge_snippet = knowledge[:2000] + "..." if len(knowledge) > 2000 else knowledge + knowledge_info_str += ( + f"{i + 1}. 关于 '{query}' (来源: {source}): {knowledge_snippet}\n" # 格式微调，更简洁 + ) + else: + knowledge_info_str += f"{i + 1}. 发现一条格式不正确的知识记录。\n" + + if not recent_knowledge: + knowledge_info_str += "- 暂无。\n" # 更简洁的提示 + + else: + knowledge_info_str += "- 暂无。\n" + except AttributeError: + logger.warning(f"[私聊][{self.private_name}]ConversationInfo 对象可能缺少 knowledge_list 属性。") + knowledge_info_str += "- 获取知识列表时出错。\n" + except Exception as e: + logger.error(f"[私聊][{self.private_name}]构建知识信息字符串时出错: {e}") + knowledge_info_str += "- 处理知识列表时出错。\n" + + # 获取聊天历史记录 (chat_history_text) + chat_history_text = observation_info.chat_history_str + if observation_info.new_messages_count > 0 and observation_info.unprocessed_messages: + new_messages_list = observation_info.unprocessed_messages + new_messages_str = await build_readable_messages( + new_messages_list, + replace_bot_name=True, + merge_messages=False, + timestamp_mode="relative", + read_mark=0.0, + ) + chat_history_text += f"\n--- 以下是 {observation_info.new_messages_count} 条新消息 ---\n{new_messages_str}" + elif not chat_history_text: + chat_history_text = "还没有聊天记录。" + + # 构建 Persona 文本 (persona_text) + persona_text = f"你的名字是{self.name}，{self.personality_info}。" + + # --- 选择 Prompt --- + if action_type == "send_new_message": + prompt_template = PROMPT_SEND_NEW_MESSAGE + logger.info(f"[私聊][{self.private_name}]使用 PROMPT_SEND_NEW_MESSAGE (追问生成)") + elif action_type == "say_goodbye": # 处理告别动作 + prompt_template = PROMPT_FAREWELL + logger.info(f"[私聊][{self.private_name}]使用 PROMPT_FAREWELL (告别语生成)") + else: # 默认使用 direct_reply 的 prompt (包括 'direct_reply' 或其他未明确处理的类型) + prompt_template = PROMPT_DIRECT_REPLY + logger.info(f"[私聊][{self.private_name}]使用 PROMPT_DIRECT_REPLY (首次/非连续回复生成)") + + # --- 格式化最终的 Prompt --- + prompt = prompt_template.format( + persona_text=persona_text, + goals_str=goals_str, + chat_history_text=chat_history_text, + knowledge_info_str=knowledge_info_str, + ) + + # --- 调用 LLM 生成 --- + logger.debug(f"[私聊][{self.private_name}]发送到LLM的生成提示词:\n------\n{prompt}\n------") + try: + content, _ = await self.llm.generate_response_async(prompt) + logger.debug(f"[私聊][{self.private_name}]生成的回复: {content}") + # 移除旧的检查新消息逻辑，这应该由 conversation 控制流处理 + return content + + except Exception as e: + logger.error(f"[私聊][{self.private_name}]生成回复时出错: {e}") + return "抱歉，我现在有点混乱，让我重新思考一下..." + + # check_reply 方法保持不变 + async def check_reply( + self, reply: str, goal: str, chat_history: List[Dict[str, Any]], chat_history_str: str, retry_count: int = 0 + ) -> Tuple[bool, str, bool]: + """检查回复是否合适 + (此方法逻辑保持不变) + """ + return await self.reply_checker.check(reply, goal, chat_history, chat_history_str, retry_count) diff --git a/src/chat/brain_chat/PFC/waiter.py b/src/chat/brain_chat/PFC/waiter.py new file mode 100644 index 00000000..0f5881fc --- /dev/null +++ b/src/chat/brain_chat/PFC/waiter.py @@ -0,0 +1,79 @@ +from src.common.logger import get_module_logger +from .chat_observer import ChatObserver +from .conversation_info import ConversationInfo + +# from src.individuality.individuality import Individuality # 不再需要 +from ...config.config import global_config +import time +import asyncio + +logger = get_module_logger("waiter") + +# --- 在这里设定你想要的超时时间（秒） --- +# 例如： 120 秒 = 2 分钟 +DESIRED_TIMEOUT_SECONDS = 300 + + +class Waiter: + """等待处理类""" + + def __init__(self, stream_id: str, private_name: str): + self.chat_observer = ChatObserver.get_instance(stream_id, private_name) + self.name = global_config.BOT_NICKNAME + self.private_name = private_name + # self.wait_accumulated_time = 0 # 不再需要累加计时 + + async def wait(self, conversation_info: ConversationInfo) -> bool: + """等待用户新消息或超时""" + wait_start_time = time.time() + logger.info(f"[私聊][{self.private_name}]进入常规等待状态 (超时: {DESIRED_TIMEOUT_SECONDS} 秒)...") + + while True: + # 检查是否有新消息 + if self.chat_observer.new_message_after(wait_start_time): + logger.info(f"[私聊][{self.private_name}]等待结束，收到新消息") + return False # 返回 False 表示不是超时 + + # 检查是否超时 + elapsed_time = time.time() - wait_start_time + if elapsed_time > DESIRED_TIMEOUT_SECONDS: + logger.info(f"[私聊][{self.private_name}]等待超过 {DESIRED_TIMEOUT_SECONDS} 秒...添加思考目标。") + wait_goal = { + "goal": f"你等待了{elapsed_time / 60:.1f}分钟，注意可能在对方看来聊天已经结束，思考接下来要做什么", + "reasoning": "对方很久没有回复你的消息了", + } + conversation_info.goal_list.append(wait_goal) + logger.info(f"[私聊][{self.private_name}]添加目标: {wait_goal}") + return True # 返回 True 表示超时 + + await asyncio.sleep(5) # 每 5 秒检查一次 + logger.debug( + f"[私聊][{self.private_name}]等待中..." + ) # 可以考虑把这个频繁日志注释掉，只在超时或收到消息时输出 + + async def wait_listening(self, conversation_info: ConversationInfo) -> bool: + """倾听用户发言或超时""" + wait_start_time = time.time() + logger.info(f"[私聊][{self.private_name}]进入倾听等待状态 (超时: {DESIRED_TIMEOUT_SECONDS} 秒)...") + + while True: + # 检查是否有新消息 + if self.chat_observer.new_message_after(wait_start_time): + logger.info(f"[私聊][{self.private_name}]倾听等待结束，收到新消息") + return False # 返回 False 表示不是超时 + + # 检查是否超时 + elapsed_time = time.time() - wait_start_time + if elapsed_time > DESIRED_TIMEOUT_SECONDS: + logger.info(f"[私聊][{self.private_name}]倾听等待超过 {DESIRED_TIMEOUT_SECONDS} 秒...添加思考目标。") + wait_goal = { + # 保持 goal 文本一致 + "goal": f"你等待了{elapsed_time / 60:.1f}分钟，对方似乎话说一半突然消失了，可能忙去了？也可能忘记了回复？要问问吗？还是结束对话？或继续等待？思考接下来要做什么", + "reasoning": "对方话说一半消失了，很久没有回复", + } + conversation_info.goal_list.append(wait_goal) + logger.info(f"[私聊][{self.private_name}]添加目标: {wait_goal}") + return True # 返回 True 表示超时 + + await asyncio.sleep(5) # 每 5 秒检查一次 + logger.debug(f"[私聊][{self.private_name}]倾听等待中...") # 同上，可以考虑注释掉 diff --git a/src/chat/brain_chat/brain_chat.py b/src/chat/brain_chat/brain_chat.py index 3624646f..b555bf0f 100644 --- a/src/chat/brain_chat/brain_chat.py +++ b/src/chat/brain_chat/brain_chat.py @@ -16,7 +16,8 @@ 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.express.expression_learner import expression_learner_manager +from src.bw_learner.expression_learner import expression_learner_manager +from src.bw_learner.message_recorder import extract_and_distribute_messages 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,6 +97,9 @@ class BrainChatting: self.more_plan = False + # 最近一次是否成功进行了 reply，用于选择 BrainPlanner 的 Prompt + self._last_successful_reply: bool = False + async def start(self): """检查是否需要启动主循环，如果未激活则启动。""" @@ -157,6 +161,7 @@ class BrainChatting: ) async def _loopbody(self): # sourcery skip: hoist-if-from-if + # 获取最新消息（用于上下文，但不影响是否调用 observe） recent_messages_list = message_api.get_messages_by_time_in_chat( chat_id=self.stream_id, start_time=self.last_read_time, @@ -164,17 +169,26 @@ class BrainChatting: limit=20, limit_mode="latest", filter_mai=True, - filter_command=True, + filter_command=False, + filter_intercept_message_level=1, ) + # 如果有新消息，更新 last_read_time if len(recent_messages_list) >= 1: self.last_read_time = time.time() - await self._observe(recent_messages_list=recent_messages_list) - else: - # Normal模式：消息数量不足，等待 - await asyncio.sleep(0.2) - return True + # 总是执行一次思考迭代（不管有没有新消息） + # wait 动作会在其内部等待，不需要在这里处理 + should_continue = await self._observe(recent_messages_list=recent_messages_list) + + if not should_continue: + # 选择了 complete_talk，返回 False 表示需要等待新消息 + return False + + # 继续下一次迭代（除非选择了 complete_talk） + # 短暂等待后再继续，避免过于频繁的循环 + await asyncio.sleep(0.1) + return True async def _send_and_store_reply( @@ -235,8 +249,32 @@ class BrainChatting: recent_messages_list = [] _reply_text = "" # 初始化reply_text变量，避免UnboundLocalError + # ------------------------------------------------------------------------- + # ReflectTracker Check + # 在每次回复前检查一次上下文，看是否有反思问题得到了解答 + # ------------------------------------------------------------------------- + from src.bw_learner.reflect_tracker import reflect_tracker_manager + + tracker = reflect_tracker_manager.get_tracker(self.stream_id) + if tracker: + resolved = await tracker.trigger_tracker() + if resolved: + reflect_tracker_manager.remove_tracker(self.stream_id) + logger.info(f"{self.log_prefix} ReflectTracker resolved and removed.") + + # ------------------------------------------------------------------------- + # Expression Reflection Check + # 检查是否需要提问表达反思 + # ------------------------------------------------------------------------- + from src.bw_learner.expression_reflector import expression_reflector_manager + + reflector = expression_reflector_manager.get_or_create_reflector(self.stream_id) + asyncio.create_task(reflector.check_and_ask()) + async with global_prompt_manager.async_message_scope(self.chat_stream.context.get_template_name()): - asyncio.create_task(self.expression_learner.trigger_learning_for_chat()) + # 通过 MessageRecorder 统一提取消息并分发给 expression_learner 和 jargon_miner + # 在 replyer 执行时触发，统一管理时间窗口，避免重复获取消息 + asyncio.create_task(extract_and_distribute_messages(self.stream_id)) cycle_timers, thinking_id = self.start_cycle() logger.info(f"{self.log_prefix} 开始第{self._cycle_counter}次思考") @@ -249,13 +287,16 @@ class BrainChatting: except Exception as e: logger.error(f"{self.log_prefix} 动作修改失败: {e}") - # 执行planner + # 获取必要信息 is_group_chat, chat_target_info, _ = self.action_planner.get_necessary_info() + # 一次思考迭代：Think - Act - Observe + # 获取聊天上下文 message_list_before_now = get_raw_msg_before_timestamp_with_chat( chat_id=self.stream_id, timestamp=time.time(), limit=int(global_config.chat.max_context_size * 0.6), + filter_intercept_message_level=1, ) chat_content_block, message_id_list = build_readable_messages_with_id( messages=message_list_before_now, @@ -266,12 +307,11 @@ class BrainChatting: ) prompt_info = await self.action_planner.build_planner_prompt( - is_group_chat=is_group_chat, chat_target_info=chat_target_info, current_available_actions=available_actions, chat_content_block=chat_content_block, message_id_list=message_id_list, - interest=global_config.personality.interest, + prompt_key="brain_planner_prompt_react", ) continue_flag, modified_message = await events_manager.handle_mai_events( EventType.ON_PLAN, None, prompt_info[0], None, self.chat_stream.stream_id @@ -287,7 +327,10 @@ class BrainChatting: available_actions=available_actions, ) - # 3. 并行执行所有动作 + # 检查是否有 complete_talk 动作（会停止后续迭代） + has_complete_talk = any(action.action_type == "complete_talk" for action in action_to_use_info) + + # 并行执行所有动作 action_tasks = [ asyncio.create_task( self._execute_action(action, action_to_use_info, thinking_id, available_actions, cycle_timers) @@ -319,7 +362,14 @@ class BrainChatting: else: logger.warning(f"{self.log_prefix} 回复动作执行失败") - # 构建最终的循环信息 + # 更新观察时间标记 + self.action_planner.last_obs_time_mark = time.time() + + # 如果选择了 complete_talk，标记为完成，不再继续迭代 + if has_complete_talk: + logger.info(f"{self.log_prefix} 检测到 complete_talk 动作，本次思考完成") + + # 构建循环信息 if reply_loop_info: # 如果有回复信息，使用回复的loop_info作为基础 loop_info = reply_loop_info @@ -345,10 +395,16 @@ class BrainChatting: } _reply_text = action_reply_text + # 如果选择了 complete_talk，返回 False 以停止 _loopbody 的循环 + # 否则返回 True，让 _loopbody 继续下一次迭代 + should_continue = not has_complete_talk + self.end_cycle(loop_info, cycle_timers) self.print_cycle_info(cycle_timers) - return True + # 如果选择了 complete_talk，返回 False 停止循环 + # 否则返回 True，继续下一次思考迭代 + return should_continue async def _main_chat_loop(self): """主循环，持续进行计划并可能回复消息，直到被外部取消。""" @@ -356,9 +412,13 @@ class BrainChatting: while self.running: # 主循环 success = await self._loopbody() - await asyncio.sleep(0.1) if not success: - break + # 选择了 complete，等待新消息 + logger.info(f"{self.log_prefix} 选择了 complete，等待新消息...") + await self._wait_for_new_message() + # 有新消息后继续循环 + continue + await asyncio.sleep(0.1) except asyncio.CancelledError: # 设置了关闭标志位后被取消是正常流程 logger.info(f"{self.log_prefix} 麦麦已关闭聊天") @@ -369,6 +429,33 @@ class BrainChatting: self._loop_task = asyncio.create_task(self._main_chat_loop()) logger.error(f"{self.log_prefix} 结束了当前聊天循环") + async def _wait_for_new_message(self): + """等待新消息到达""" + last_check_time = self.last_read_time + check_interval = 1.0 # 每秒检查一次 + + while self.running: + # 检查是否有新消息 + recent_messages_list = message_api.get_messages_by_time_in_chat( + chat_id=self.stream_id, + start_time=last_check_time, + end_time=time.time(), + limit=20, + limit_mode="latest", + filter_mai=True, + filter_command=False, + filter_intercept_message_level=1, + ) + + # 如果有新消息，更新 last_read_time 并返回 + if len(recent_messages_list) >= 1: + self.last_read_time = time.time() + logger.info(f"{self.log_prefix} 检测到新消息，恢复循环") + return + + # 等待一段时间后再次检查 + await asyncio.sleep(check_interval) + async def _handle_action( self, action: str, @@ -482,12 +569,12 @@ class BrainChatting: """执行单个动作的通用函数""" try: with Timer(f"动作{action_planner_info.action_type}", cycle_timers): - if action_planner_info.action_type == "no_reply": - # 直接处理no_reply逻辑，不再通过动作系统 - reason = action_planner_info.reasoning or "选择不回复" - # logger.info(f"{self.log_prefix} 选择不回复，原因: {reason}") + if action_planner_info.action_type == "complete_talk": + # 直接处理complete_talk逻辑，不再通过动作系统 + reason = action_planner_info.reasoning or "选择完成对话" + logger.info(f"{self.log_prefix} 选择完成对话，原因: {reason}") - # 存储no_reply信息到数据库 + # 存储complete_talk信息到数据库 await database_api.store_action_info( chat_stream=self.chat_stream, action_build_into_prompt=False, @@ -495,18 +582,33 @@ class BrainChatting: action_done=True, thinking_id=thinking_id, action_data={"reason": reason}, - action_name="no_reply", + action_name="complete_talk", ) - return {"action_type": "no_reply", "success": True, "reply_text": "", "command": ""} + return {"action_type": "complete_talk", "success": True, "reply_text": "", "command": ""} elif action_planner_info.action_type == "reply": try: + # 从 Planner 的 action_data 中提取未知词语列表（仅在 reply 时使用） + unknown_words = None + if isinstance(action_planner_info.action_data, dict): + uw = action_planner_info.action_data.get("unknown_words") + if isinstance(uw, list): + cleaned_uw: List[str] = [] + for item in uw: + if isinstance(item, str): + s = item.strip() + if s: + cleaned_uw.append(s) + if cleaned_uw: + unknown_words = cleaned_uw + 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 "", + unknown_words=unknown_words, enable_tool=global_config.tool.enable_tool, request_type="replyer", from_plugin=False, @@ -519,11 +621,17 @@ class BrainChatting: ) else: logger.info("回复生成失败") - return {"action_type": "reply", "success": False, "reply_text": "", "loop_info": None} + 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( @@ -534,6 +642,8 @@ class BrainChatting: actions=chosen_action_plan_infos, selected_expressions=selected_expressions, ) + # 标记这次循环已经成功进行了回复 + self._last_successful_reply = True return { "action_type": "reply", "success": True, @@ -543,7 +653,88 @@ class BrainChatting: # 其他动作 else: - # 执行普通动作 + # 内建 wait / listening：不通过插件系统，直接在这里处理 + if action_planner_info.action_type in ["wait", "listening"]: + reason = action_planner_info.reasoning or "" + action_data = action_planner_info.action_data or {} + + if action_planner_info.action_type == "wait": + # 获取等待时间（必填） + wait_seconds = action_data.get("wait_seconds") + if wait_seconds is None: + logger.warning(f"{self.log_prefix} wait 动作缺少 wait_seconds 参数，使用默认值 5 秒") + wait_seconds = 5 + else: + try: + wait_seconds = float(wait_seconds) + if wait_seconds < 0: + logger.warning(f"{self.log_prefix} wait_seconds 不能为负数，使用默认值 5 秒") + wait_seconds = 5 + except (ValueError, TypeError): + logger.warning(f"{self.log_prefix} wait_seconds 参数格式错误，使用默认值 5 秒") + wait_seconds = 5 + + logger.info(f"{self.log_prefix} 执行 wait 动作，等待 {wait_seconds} 秒") + + # 记录动作信息 + await database_api.store_action_info( + chat_stream=self.chat_stream, + action_build_into_prompt=False, + action_prompt_display=reason or f"等待 {wait_seconds} 秒", + action_done=True, + thinking_id=thinking_id, + action_data={"reason": reason, "wait_seconds": wait_seconds}, + action_name="wait", + ) + + # 等待指定时间 + await asyncio.sleep(wait_seconds) + + logger.info(f"{self.log_prefix} wait 动作完成，继续下一次思考") + + # 这些动作本身不产生文本回复 + self._last_successful_reply = False + return { + "action_type": "wait", + "success": True, + "reply_text": "", + "command": "", + } + + # listening 已合并到 wait，如果遇到则转换为 wait（向后兼容） + elif action_planner_info.action_type == "listening": + logger.debug(f"{self.log_prefix} 检测到 listening 动作，已合并到 wait，自动转换") + # 使用默认等待时间 + wait_seconds = 3 + + logger.info(f"{self.log_prefix} 执行 listening（转换为 wait）动作，等待 {wait_seconds} 秒") + + # 记录动作信息 + await database_api.store_action_info( + chat_stream=self.chat_stream, + action_build_into_prompt=False, + action_prompt_display=reason or f"倾听并等待 {wait_seconds} 秒", + action_done=True, + thinking_id=thinking_id, + action_data={"reason": reason, "wait_seconds": wait_seconds}, + action_name="listening", + ) + + # 等待指定时间 + await asyncio.sleep(wait_seconds) + + logger.info(f"{self.log_prefix} listening 动作完成，继续下一次思考") + + # 这些动作本身不产生文本回复 + self._last_successful_reply = False + return { + "action_type": "listening", + "success": True, + "reply_text": "", + "command": "", + } + + # 其余动作：走原有插件 Action 体系 with Timer("动作执行", cycle_timers): success, reply_text, command = await self._handle_action( action_planner_info.action_type, @@ -553,6 +744,10 @@ class BrainChatting: thinking_id, action_planner_info.action_message, ) + # 非 reply 类动作执行成功时，清空最近成功回复标记，让下一轮回到 initial Prompt + if success and action_planner_info.action_type != "reply": + self._last_successful_reply = False + return { "action_type": action_planner_info.action_type, "success": success, diff --git a/src/chat/brain_chat/brain_planner.py b/src/chat/brain_chat/brain_planner.py index 55a8771b..14d28575 100644 --- a/src/chat/brain_chat/brain_planner.py +++ b/src/chat/brain_chat/brain_planner.py @@ -35,12 +35,13 @@ install(extra_lines=3) def init_prompt(): + # ReAct 形式的 Planner Prompt Prompt( """ {time_block} {name_block} -你的兴趣是：{interest} {chat_context_description}，以下是具体的聊天内容 + **聊天内容** {chat_content_block} @@ -57,11 +58,35 @@ reply "reason":"回复的原因" }} -no_reply +wait 动作描述： -等待，保持沉默，等待对方发言 +暂时不再发言，等待指定时间。适用于以下情况： +- 你已经表达清楚一轮，想给对方留出空间 +- 你感觉对方的话还没说完，或者自己刚刚发了好几条连续消息 +- 你想要等待一定时间来让对方把话说完，或者等待对方反应 +- 你想保持安静，专注"听"而不是马上回复 +请你根据上下文来判断要等待多久，请你灵活判断： +- 如果你们交流间隔时间很短，聊的很频繁，不宜等待太久 +- 如果你们交流间隔时间很长，聊的很少，可以等待较长时间 {{ - "action": "no_reply", + "action": "wait", + "target_message_id":"想要作为这次等待依据的消息id（通常是对方的最新消息）", + "wait_seconds": 等待的秒数（必填，例如：5 表示等待5秒）, + "reason":"选择等待的原因" +}} + +complete_talk +动作描述： +当前聊天暂时结束了，对方离开，没有更多话题了 +你可以使用该动作来暂时休息，等待对方有新发言再继续： +- 多次wait之后，对方迟迟不回复消息才用 +- 如果对方只是短暂不回复，应该使用wait而不是complete_talk +- 聊天内容显示当前聊天已经结束或者没有新内容时候，选择complete_talk +选择此动作后，将不再继续循环思考，直到收到对方的新消息 +{{ + "action": "complete_talk", + "target_message_id":"触发完成对话的消息id（通常是对方的最新消息）", + "reason":"选择完成对话的原因" }} {action_options_text} @@ -92,7 +117,7 @@ no_reply ``` """, - "brain_planner_prompt", + "brain_planner_prompt_react", ) Prompt( @@ -123,6 +148,9 @@ class BrainPlanner: self.last_obs_time_mark = 0.0 + # 计划日志记录 + self.plan_log: List[Tuple[str, float, List[ActionPlannerInfo]]] = [] + def find_message_by_id( self, message_id: str, message_id_list: List[Tuple[str, "DatabaseMessages"]] ) -> Optional["DatabaseMessages"]: @@ -152,10 +180,11 @@ class BrainPlanner: action_planner_infos = [] try: - action = action_json.get("action", "no_reply") + action = action_json.get("action", "complete_talk") + logger.debug(f"{self.log_prefix}解析动作JSON: action={action}, json={action_json}") reasoning = action_json.get("reason", "未提供原因") action_data = {key: value for key, value in action_json.items() if key not in ["action", "reason"]} - # 非no_reply动作需要target_message_id + # 非complete_talk动作需要target_message_id target_message = None if target_message_id := action_json.get("target_message_id"): @@ -171,16 +200,28 @@ class BrainPlanner: # 验证action是否可用 available_action_names = [action_name for action_name, _ in current_available_actions] - internal_action_names = ["no_reply", "reply", "wait_time"] + # 内部保留动作（不依赖插件系统） + # 注意：listening 已合并到 wait 中，如果遇到 listening 则转换为 wait + internal_action_names = ["complete_talk", "reply", "wait_time", "wait", "listening"] + + logger.debug( + f"{self.log_prefix}动作验证: action={action}, internal={internal_action_names}, available={available_action_names}" + ) + + # 将 listening 转换为 wait（向后兼容） + if action == "listening": + logger.debug(f"{self.log_prefix}检测到 listening 动作，已合并到 wait，自动转换") + action = "wait" if action not in internal_action_names and action not in available_action_names: logger.warning( - f"{self.log_prefix}LLM 返回了当前不可用或无效的动作: '{action}' (可用: {available_action_names})，将强制使用 'no_reply'" + f"{self.log_prefix}LLM 返回了当前不可用或无效的动作: '{action}' (内部动作: {internal_action_names}, 可用插件动作: {available_action_names})，将强制使用 'complete_talk'" ) reasoning = ( f"LLM 返回了当前不可用的动作 '{action}' (可用: {available_action_names})。原始理由: {reasoning}" ) - action = "no_reply" + action = "complete_talk" + logger.warning(f"{self.log_prefix}动作已转换为 complete_talk") # 创建ActionPlannerInfo对象 # 将列表转换为字典格式 @@ -201,7 +242,7 @@ class BrainPlanner: available_actions_dict = dict(current_available_actions) action_planner_infos.append( ActionPlannerInfo( - action_type="no_reply", + action_type="complete_talk", reasoning=f"解析单个action时出错: {e}", action_data={}, action_message=None, @@ -218,7 +259,7 @@ class BrainPlanner: ) -> List[ActionPlannerInfo]: # sourcery skip: use-named-expression """ - 规划器 (Planner): 使用LLM根据上下文决定做出什么动作。 + 规划器 (Planner): 使用LLM根据上下文决定做出什么动作（ReAct模式）。 """ # 获取聊天上下文 @@ -226,6 +267,7 @@ class BrainPlanner: chat_id=self.chat_id, timestamp=time.time(), limit=int(global_config.chat.max_context_size * 0.6), + filter_intercept_message_level=1, ) message_id_list: list[Tuple[str, "DatabaseMessages"]] = [] chat_content_block, message_id_list = build_readable_messages_with_id( @@ -256,18 +298,19 @@ class BrainPlanner: logger.debug(f"{self.log_prefix}过滤后有{len(filtered_actions)}个可用动作") - # 构建包含所有动作的提示词 + # 构建包含所有动作的提示词：使用统一的 ReAct Prompt + prompt_key = "brain_planner_prompt_react" + # 这里不记录日志，避免重复打印，由调用方按需控制 log_prompt prompt, message_id_list = await self.build_planner_prompt( - is_group_chat=is_group_chat, chat_target_info=chat_target_info, current_available_actions=filtered_actions, chat_content_block=chat_content_block, message_id_list=message_id_list, - interest=global_config.personality.interest, + prompt_key=prompt_key, ) # 调用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, @@ -275,16 +318,22 @@ class BrainPlanner: loop_start_time=loop_start_time, ) + # 记录和展示计划日志 + 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 async def build_planner_prompt( self, - is_group_chat: bool, chat_target_info: Optional["TargetPersonInfo"], current_available_actions: Dict[str, ActionInfo], message_id_list: List[Tuple[str, "DatabaseMessages"]], chat_content_block: str = "", interest: str = "", + prompt_key: str = "brain_planner_prompt_react", ) -> tuple[str, List[Tuple[str, "DatabaseMessages"]]]: """构建 Planner LLM 的提示词 (获取模板并填充数据)""" try: @@ -320,7 +369,7 @@ class BrainPlanner: name_block = f"你的名字是{bot_name}{bot_nickname}，请注意哪些是你自己的发言。" # 获取主规划器模板并填充 - planner_prompt_template = await global_prompt_manager.get_prompt_async("brain_planner_prompt") + planner_prompt_template = await global_prompt_manager.get_prompt_async(prompt_key) prompt = planner_prompt_template.format( time_block=time_block, chat_context_description=chat_context_description, @@ -430,17 +479,18 @@ class BrainPlanner: 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] = [] + extracted_reasoning = "" try: # 调用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_planner_prompt: logger.info(f"{self.log_prefix}规划器原始提示词: {prompt}") @@ -455,10 +505,11 @@ class BrainPlanner: except Exception as req_e: logger.error(f"{self.log_prefix}LLM 请求执行失败: {req_e}") - return [ + extracted_reasoning = f"LLM 请求失败，模型出现问题: {req_e}" + return extracted_reasoning, [ ActionPlannerInfo( - action_type="no_reply", - reasoning=f"LLM 请求失败，模型出现问题: {req_e}", + action_type="complete_talk", + reasoning=extracted_reasoning, action_data={}, action_message=None, available_actions=available_actions, @@ -468,24 +519,32 @@ class BrainPlanner: # 解析LLM响应 if llm_content: try: - if json_objects := self._extract_json_from_markdown(llm_content): - logger.debug(f"{self.log_prefix}从响应中提取到{len(json_objects)}个JSON对象") + json_objects, extracted_reasoning = self._extract_json_from_markdown(llm_content) + if json_objects: + logger.info(f"{self.log_prefix}从响应中提取到{len(json_objects)}个JSON对象") + for i, json_obj in enumerate(json_objects): + logger.info(f"{self.log_prefix}解析第{i + 1}个JSON对象: {json_obj}") 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)) + parsed_actions = self._parse_single_action(json_obj, message_id_list, filtered_actions_list) + logger.info(f"{self.log_prefix}解析后的动作: {[a.action_type for a in parsed_actions]}") + actions.extend(parsed_actions) else: # 尝试解析为直接的JSON logger.warning(f"{self.log_prefix}LLM没有返回可用动作: {llm_content}") - actions = self._create_no_reply("LLM没有返回可用动作", available_actions) + extracted_reasoning = extracted_reasoning or "LLM没有返回可用动作" + actions = self._create_complete_talk(extracted_reasoning, available_actions) except Exception as json_e: logger.warning(f"{self.log_prefix}解析LLM响应JSON失败 {json_e}. LLM原始输出: '{llm_content}'") - actions = self._create_no_reply(f"解析LLM响应JSON失败: {json_e}", available_actions) + extracted_reasoning = f"解析LLM响应JSON失败: {json_e}" + actions = self._create_complete_talk(extracted_reasoning, available_actions) traceback.print_exc() else: - actions = self._create_no_reply("规划器没有获得LLM响应", available_actions) + extracted_reasoning = "规划器没有获得LLM响应" + actions = self._create_complete_talk(extracted_reasoning, available_actions) - # 添加循环开始时间到所有非no_reply动作 + # 添加循环开始时间到所有动作 for action in actions: action.action_data = action.action_data or {} action.action_data["loop_start_time"] = loop_start_time @@ -494,13 +553,15 @@ class BrainPlanner: 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_reply""" + def _create_complete_talk( + self, reasoning: str, available_actions: Dict[str, ActionInfo] + ) -> List[ActionPlannerInfo]: + """创建complete_talk""" return [ ActionPlannerInfo( - action_type="no_reply", + action_type="complete_talk", reasoning=reasoning, action_data={}, action_message=None, @@ -508,33 +569,122 @@ class BrainPlanner: ) ] - def _extract_json_from_markdown(self, content: str) -> List[dict]: + 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 _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) + markdown_matches = re.findall(json_pattern, content, re.DOTALL) - for match in matches: + # 提取JSON之前的内容作为推理文本 + first_json_pos = len(content) + if markdown_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() + + # 处理```json包裹的JSON + for match in markdown_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(repair_json(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) + # 先尝试将整个块作为一个JSON对象或数组（适用于多行JSON） + try: + json_obj = json.loads(repair_json(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 json.JSONDecodeError: + # 如果整个块解析失败，尝试按行分割（适用于多个单行JSON对象） + lines = [line.strip() for line in json_str.split("\n") if line.strip()] + for line in lines: + try: + # 尝试解析每一行作为独立的JSON对象 + json_obj = json.loads(repair_json(line)) + 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 json.JSONDecodeError: + # 单行解析失败，继续下一行 + continue except Exception as e: - logger.warning(f"解析JSON块失败: {e}, 块内容: {match[:100]}...") + logger.warning(f"{self.log_prefix}解析JSON块失败: {e}, 块内容: {match[:100]}...") continue - return json_objects + # 如果没有找到完整的```json```块，尝试查找不完整的代码块（缺少结尾```） + if not json_objects: + json_start_pos = content.find("```json") + if json_start_pos != -1: + # 找到```json之后的内容 + json_content_start = json_start_pos + 7 # ```json的长度 + # 提取从```json之后到内容结尾的所有内容 + incomplete_json_str = content[json_content_start:].strip() + + # 提取JSON之前的内容作为推理文本 + if json_start_pos > 0: + reasoning_content = content[:json_start_pos].strip() + reasoning_content = re.sub(r"^//\s*", "", reasoning_content, flags=re.MULTILINE) + reasoning_content = reasoning_content.strip() + + if incomplete_json_str: + try: + # 清理可能的注释和格式问题 + json_str = re.sub(r"//.*?\n", "\n", incomplete_json_str) + json_str = re.sub(r"/\*.*?\*/", "", json_str, flags=re.DOTALL) + json_str = json_str.strip() + + if json_str: + # 尝试按行分割，每行可能是一个JSON对象 + lines = [line.strip() for line in json_str.split("\n") if line.strip()] + for line in lines: + try: + json_obj = json.loads(repair_json(line)) + 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 json.JSONDecodeError: + pass + + # 如果按行解析没有成功，尝试将整个块作为一个JSON对象或数组 + if not json_objects: + try: + json_obj = json.loads(repair_json(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.debug(f"尝试解析不完整的JSON代码块失败: {e}") + except Exception as e: + logger.debug(f"处理不完整的JSON代码块时出错: {e}") + + return json_objects, reasoning_content init_prompt() diff --git a/src/chat/emoji_system/emoji_manager.py b/src/chat/emoji_system/emoji_manager.py index 1a562fcc..af12bb1a 100644 --- a/src/chat/emoji_system/emoji_manager.py +++ b/src/chat/emoji_system/emoji_manager.py @@ -13,7 +13,7 @@ from typing import Optional, Tuple, List, Any from PIL import Image from rich.traceback import install -from src.common.database.database_model import Emoji +from src.common.database.database_model import Emoji, EmojiDescriptionCache from src.common.database.database import db as peewee_db from src.common.logger import get_logger from src.config.config import global_config, model_config @@ -271,7 +271,7 @@ def _to_emoji_objects(data: Any) -> Tuple[List["MaiEmoji"], int]: emoji.description = emoji_data.description # Deserialize emotion string from DB to list - emoji.emotion = emoji_data.emotion.split(",") if emoji_data.emotion else [] + emoji.emotion = emoji_data.emotion.replace("，", ",").split(",") if emoji_data.emotion else [] emoji.usage_count = emoji_data.usage_count db_last_used_time = emoji_data.last_used_time @@ -356,7 +356,7 @@ async def clean_unused_emojis(emoji_dir: str, emoji_objects: List["MaiEmoji"], r if cleaned_count > 0: logger.info(f"[清理] 在目录 {emoji_dir} 中清理了 {cleaned_count} 个破损表情包。") else: - logger.info(f"[清理] 目录 {emoji_dir} 中没有需要清理的。") + logger.debug(f"[清理] 目录 {emoji_dir} 中没有需要清理的。") except Exception as e: logger.error(f"[错误] 清理未使用表情包文件时出错 ({emoji_dir}): {str(e)}") @@ -398,6 +398,7 @@ class EmojiManager: raise RuntimeError("数据库连接失败") _ensure_emoji_dir() Emoji.create_table(safe=True) # Ensures table exists + EmojiDescriptionCache.create_table(safe=True) self._initialized = True def _ensure_db(self) -> None: @@ -731,7 +732,7 @@ class EmojiManager: emoji_record = Emoji.get_or_none(Emoji.emoji_hash == emoji_hash) if emoji_record and emoji_record.emotion: logger.info(f"[缓存命中] 从数据库获取表情包情感标签: {emoji_record.emotion[:50]}...") - return emoji_record.emotion.split(",") + return emoji_record.emotion.replace("，", ",").split(",") except Exception as e: logger.error(f"从数据库查询表情包情感标签时出错: {e}") @@ -918,17 +919,15 @@ class EmojiManager: image_hash = hashlib.md5(image_bytes).hexdigest() image_format = Image.open(io.BytesIO(image_bytes)).format.lower() # type: ignore - # 尝试从Images表获取已有的详细描述（可能在收到表情包时已生成） + # 尝试从 EmojiDescriptionCache 表获取已有的详细描述 existing_description = None try: - from src.common.database.database_model import Images - - existing_image = Images.get_or_none((Images.emoji_hash == image_hash) & (Images.type == "emoji")) - if existing_image and existing_image.description: - existing_description = existing_image.description - logger.info(f"[复用描述] 找到已有详细描述: {existing_description[:50]}...") + cache_record = EmojiDescriptionCache.get_or_none(EmojiDescriptionCache.emoji_hash == image_hash) + if cache_record and cache_record.description: + existing_description = cache_record.description + logger.info(f"[复用描述] 表情描述缓存命中: {existing_description[:50]}...") except Exception as e: - logger.debug(f"查询已有描述时出错: {e}") + logger.debug(f"查询表情描述缓存时出错: {e}") # 第一步：VLM视觉分析（如果没有已有描述才调用） if existing_description: @@ -950,6 +949,21 @@ class EmojiManager: prompt, image_base64, image_format, temperature=0.5 ) + # 若是新生成的描述，写入缓存表（此时还没有情感标签，稍后会更新） + if not existing_description: + try: + cache_record, created = EmojiDescriptionCache.get_or_create( + emoji_hash=image_hash, + defaults={"description": description, "timestamp": time.time()}, + ) + if not created: + # 更新描述，但保留已有的情感标签（如果有） + cache_record.description = description + cache_record.timestamp = time.time() + cache_record.save() + except Exception as cache_error: + logger.debug(f"写入表情描述缓存失败: {cache_error}") + # 审核表情包 if global_config.emoji.content_filtration: prompt = f''' @@ -979,7 +993,7 @@ class EmojiManager: ) # 处理情感列表 - emotions = [e.strip() for e in emotions_text.split(",") if e.strip()] + emotions = [e.strip() for e in emotions_text.replace("，", ",").split(",") if e.strip()] # 根据情感标签数量随机选择 - 超过5个选3个，超过2个选2个 if len(emotions) > 5: @@ -989,6 +1003,30 @@ class EmojiManager: logger.info(f"[注册分析] 详细描述: {description[:50]}... -> 情感标签: {emotions}") + # 将情感标签列表转换为逗号分隔的字符串 + emotion_tags_str = ",".join(emotions) + + # 更新EmojiDescriptionCache，保存情感标签 + try: + cache_record = EmojiDescriptionCache.get_or_none(EmojiDescriptionCache.emoji_hash == image_hash) + if cache_record: + # 更新已有记录的情感标签 + cache_record.emotion_tags = emotion_tags_str + cache_record.timestamp = time.time() + cache_record.save() + logger.info(f"[缓存更新] 表情包情感标签已更新到EmojiDescriptionCache: {image_hash[:8]}...") + else: + # 如果缓存不存在，创建新记录（包含描述和情感标签） + EmojiDescriptionCache.create( + emoji_hash=image_hash, + description=description, + emotion_tags=emotion_tags_str, + timestamp=time.time(), + ) + logger.info(f"[缓存创建] 表情包描述和情感标签已保存到EmojiDescriptionCache: {image_hash[:8]}...") + except Exception as cache_error: + logger.debug(f"更新表情包情感标签缓存失败: {cache_error}") + return f"[表情包：{description}]", emotions except Exception as e: diff --git a/src/chat/frequency_control/frequency_control.py b/src/chat/frequency_control/frequency_control.py deleted file mode 100644 index 78041ae7..00000000 --- a/src/chat/frequency_control/frequency_control.py +++ /dev/null @@ -1,150 +0,0 @@ -from datetime import datetime -import time -from typing import Dict - -from src.chat.utils.chat_message_builder import ( - get_raw_msg_by_timestamp_with_chat, - build_readable_messages, -) -from src.chat.utils.prompt_builder import Prompt, global_prompt_manager -from src.config.config import global_config, model_config -from src.llm_models.utils_model import LLMRequest -from src.common.logger import get_logger -from src.plugin_system.apis import frequency_api - - -def init_prompt(): - Prompt( - """{name_block} -{time_block} -你现在正在聊天，请根据下面的聊天记录判断是否有用户觉得你的发言过于频繁或者发言过少 -{message_str} - -如果用户觉得你的发言过于频繁，请输出"过于频繁"，否则输出"正常" -如果用户觉得你的发言过少，请输出"过少"，否则输出"正常" -**你只能输出以下三个词之一，不要输出任何其他文字、解释或标点：** -- 正常 -- 过于频繁 -- 过少 -""", - "frequency_adjust_prompt", - ) - - -logger = get_logger("frequency_control") - - -class FrequencyControl: - """简化的频率控制类，仅管理不同chat_id的频率值""" - - def __init__(self, chat_id: str): - self.chat_id = chat_id - # 发言频率调整值 - self.talk_frequency_adjust: float = 1.0 - - self.last_frequency_adjust_time: float = 0.0 - self.frequency_model = LLMRequest( - model_set=model_config.model_task_config.utils_small, request_type="frequency.adjust" - ) - - def get_talk_frequency_adjust(self) -> float: - """获取发言频率调整值""" - return self.talk_frequency_adjust - - def set_talk_frequency_adjust(self, value: float) -> None: - """设置发言频率调整值""" - self.talk_frequency_adjust = max(0.1, min(5.0, value)) - - async def trigger_frequency_adjust(self) -> None: - msg_list = get_raw_msg_by_timestamp_with_chat( - chat_id=self.chat_id, - timestamp_start=self.last_frequency_adjust_time, - timestamp_end=time.time(), - ) - - if time.time() - self.last_frequency_adjust_time < 160 or len(msg_list) <= 20: - return - else: - new_msg_list = get_raw_msg_by_timestamp_with_chat( - chat_id=self.chat_id, - timestamp_start=self.last_frequency_adjust_time, - timestamp_end=time.time(), - limit=20, - limit_mode="latest", - ) - - message_str = build_readable_messages( - new_msg_list, - replace_bot_name=True, - timestamp_mode="relative", - read_mark=0.0, - show_actions=False, - ) - time_block = f"当前时间：{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}" - bot_name = global_config.bot.nickname - bot_nickname = ( - f",也有人叫你{','.join(global_config.bot.alias_names)}" if global_config.bot.alias_names else "" - ) - name_block = f"你的名字是{bot_name}{bot_nickname}，请注意哪些是你自己的发言。" - - prompt = await global_prompt_manager.format_prompt( - "frequency_adjust_prompt", - name_block=name_block, - time_block=time_block, - message_str=message_str, - ) - response, (reasoning_content, _, _) = await self.frequency_model.generate_response_async( - prompt, - ) - - # logger.info(f"频率调整 prompt: {prompt}") - # logger.info(f"频率调整 response: {response}") - - if global_config.debug.show_prompt: - logger.info(f"频率调整 prompt: {prompt}") - logger.info(f"频率调整 response: {response}") - logger.info(f"频率调整 reasoning_content: {reasoning_content}") - - final_value_by_api = frequency_api.get_current_talk_value(self.chat_id) - - # LLM依然输出过多内容时取消本次调整。合法最多4个字，但有的模型可能会输出一些markdown换行符等，需要长度宽限 - if len(response) < 20: - if "过于频繁" in response: - logger.info(f"频率调整: 过于频繁，调整值到{final_value_by_api}") - self.talk_frequency_adjust = max(0.1, min(1.5, self.talk_frequency_adjust * 0.8)) - elif "过少" in response: - logger.info(f"频率调整: 过少，调整值到{final_value_by_api}") - self.talk_frequency_adjust = max(0.1, min(1.5, self.talk_frequency_adjust * 1.2)) - self.last_frequency_adjust_time = time.time() - else: - logger.info("频率调整：response不符合要求，取消本次调整") - - -class FrequencyControlManager: - """频率控制管理器，管理多个聊天流的频率控制实例""" - - def __init__(self): - self.frequency_control_dict: Dict[str, FrequencyControl] = {} - - def get_or_create_frequency_control(self, chat_id: str) -> FrequencyControl: - """获取或创建指定聊天流的频率控制实例""" - if chat_id not in self.frequency_control_dict: - self.frequency_control_dict[chat_id] = FrequencyControl(chat_id) - return self.frequency_control_dict[chat_id] - - def remove_frequency_control(self, chat_id: str) -> bool: - """移除指定聊天流的频率控制实例""" - if chat_id in self.frequency_control_dict: - del self.frequency_control_dict[chat_id] - return True - return False - - def get_all_chat_ids(self) -> list[str]: - """获取所有有频率控制的聊天ID""" - return list(self.frequency_control_dict.keys()) - - -init_prompt() - -# 创建全局实例 -frequency_control_manager = FrequencyControlManager() diff --git a/src/chat/heart_flow/frequency_control.py b/src/chat/heart_flow/frequency_control.py new file mode 100644 index 00000000..d3be7801 --- /dev/null +++ b/src/chat/heart_flow/frequency_control.py @@ -0,0 +1,50 @@ +from typing import Dict + +from src.common.logger import get_logger + +logger = get_logger("frequency_control") + + +class FrequencyControl: + """简化的频率控制类，仅管理不同chat_id的频率值""" + + def __init__(self, chat_id: str): + self.chat_id = chat_id + # 发言频率调整值 + self.talk_frequency_adjust: float = 1.0 + + def get_talk_frequency_adjust(self) -> float: + """获取发言频率调整值""" + return self.talk_frequency_adjust + + def set_talk_frequency_adjust(self, value: float) -> None: + """设置发言频率调整值""" + self.talk_frequency_adjust = max(0.1, min(5.0, value)) + + +class FrequencyControlManager: + """频率控制管理器，管理多个聊天流的频率控制实例""" + + def __init__(self): + self.frequency_control_dict: Dict[str, FrequencyControl] = {} + + def get_or_create_frequency_control(self, chat_id: str) -> FrequencyControl: + """获取或创建指定聊天流的频率控制实例""" + if chat_id not in self.frequency_control_dict: + self.frequency_control_dict[chat_id] = FrequencyControl(chat_id) + return self.frequency_control_dict[chat_id] + + def remove_frequency_control(self, chat_id: str) -> bool: + """移除指定聊天流的频率控制实例""" + if chat_id in self.frequency_control_dict: + del self.frequency_control_dict[chat_id] + return True + return False + + def get_all_chat_ids(self) -> list[str]: + """获取所有有频率控制的聊天ID""" + return list(self.frequency_control_dict.keys()) + + +# 创建全局实例 +frequency_control_manager = FrequencyControlManager() diff --git a/src/chat/heart_flow/heartFC_chat.py b/src/chat/heart_flow/heartFC_chat.py index bb37e29e..13db1783 100644 --- a/src/chat/heart_flow/heartFC_chat.py +++ b/src/chat/heart_flow/heartFC_chat.py @@ -16,9 +16,11 @@ from src.chat.planner_actions.planner import ActionPlanner 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.express.expression_learner import expression_learner_manager -from src.chat.frequency_control.frequency_control import frequency_control_manager -from src.jargon import extract_and_store_jargon +from src.bw_learner.expression_learner import expression_learner_manager +from src.chat.heart_flow.frequency_control import frequency_control_manager +from src.bw_learner.reflect_tracker import reflect_tracker_manager +from src.bw_learner.expression_reflector import expression_reflector_manager +from src.bw_learner.message_recorder import extract_and_distribute_messages 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 @@ -27,7 +29,8 @@ from src.chat.utils.chat_message_builder import ( build_readable_messages_with_id, get_raw_msg_before_timestamp_with_chat, ) -from src.chat.utils.chat_history_summarizer import ChatHistorySummarizer +from src.chat.utils.utils import record_replyer_action_temp +from src.hippo_memorizer.chat_history_summarizer import ChatHistorySummarizer if TYPE_CHECKING: from src.common.data_models.database_data_model import DatabaseMessages @@ -97,7 +100,6 @@ class HeartFChatting: self._current_cycle_detail: CycleDetail = None # type: ignore self.last_read_time = time.time() - 2 - self.no_reply_until_call = False self.is_mute = False @@ -187,7 +189,8 @@ class HeartFChatting: limit=20, limit_mode="latest", filter_mai=True, - filter_command=True, + filter_command=False, + filter_intercept_message_level=0, ) # 根据连续 no_reply 次数动态调整阈值 @@ -204,23 +207,6 @@ class HeartFChatting: if len(recent_messages_list) >= threshold: # 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: - if ( - message.is_mentioned - or message.is_at - or len(recent_messages_list) >= 8 - 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: - # logger.info(f"{self.log_prefix} 没有提到，继续保持沉默") - await asyncio.sleep(1) - return True self.last_read_time = time.time() @@ -300,90 +286,6 @@ class HeartFChatting: return loop_info, reply_text, cycle_timers - async def _run_planner_without_reply( - self, - available_actions: Dict[str, ActionInfo], - cycle_timers: Dict[str, float], - ) -> List[ActionPlannerInfo]: - """执行planner，但不包含reply动作（用于并行执行场景，提及时使用简化版提示词）""" - try: - with Timer("规划器", cycle_timers): - action_to_use_info = await self.action_planner.plan( - loop_start_time=self.last_read_time, - available_actions=available_actions, - is_mentioned=True, # 标记为提及时，使用简化版提示词 - ) - # 过滤掉reply动作（虽然提及时不应该有reply，但为了安全还是过滤一下） - return [action for action in action_to_use_info if action.action_type != "reply"] - except Exception as e: - logger.error(f"{self.log_prefix} Planner执行失败: {e}") - traceback.print_exc() - return [] - - async def _generate_mentioned_reply( - self, - force_reply_message: "DatabaseMessages", - thinking_id: str, - cycle_timers: Dict[str, float], - available_actions: Dict[str, ActionInfo], - ) -> Dict[str, Any]: - """当被提及时，独立生成回复的任务""" - try: - self.questioned = False - # 重置连续 no_reply 计数 - self.consecutive_no_reply_count = 0 - reason = "" - - 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, - ) - - with Timer("提及回复生成", cycle_timers): - success, llm_response = await generator_api.generate_reply( - chat_stream=self.chat_stream, - reply_message=force_reply_message, - available_actions=available_actions, - chosen_actions=[], # 独立回复，不依赖planner的动作 - reply_reason=reason, - enable_tool=global_config.tool.enable_tool, - request_type="replyer", - from_plugin=False, - reply_time_point=self.last_read_time, - ) - - if not success or not llm_response or not llm_response.reply_set: - logger.warning(f"{self.log_prefix} 提及回复生成失败") - return {"action_type": "reply", "success": False, "result": "提及回复生成失败", "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( - response_set=response_set, - action_message=force_reply_message, - cycle_timers=cycle_timers, - thinking_id=thinking_id, - actions=[], # 独立回复，不依赖planner的动作 - selected_expressions=selected_expressions, - ) - self.last_active_time = time.time() - return { - "action_type": "reply", - "success": True, - "result": f"你回复内容{reply_text}", - "loop_info": loop_info, - } - except Exception as e: - logger.error(f"{self.log_prefix} 提及回复生成异常: {e}") - traceback.print_exc() - return {"action_type": "reply", "success": False, "result": f"提及回复生成异常: {e}", "loop_info": None} - async def _observe( self, # interest_value: float = 0.0, recent_messages_list: Optional[List["DatabaseMessages"]] = None, @@ -393,24 +295,36 @@ class HeartFChatting: recent_messages_list = [] _reply_text = "" # 初始化reply_text变量，避免UnboundLocalError - start_time = time.time() + # ------------------------------------------------------------------------- + # ReflectTracker Check + # 在每次回复前检查一次上下文，看是否有反思问题得到了解答 + # ------------------------------------------------------------------------- + reflector = expression_reflector_manager.get_or_create_reflector(self.stream_id) + await reflector.check_and_ask() + tracker = reflect_tracker_manager.get_tracker(self.stream_id) + if tracker: + resolved = await tracker.trigger_tracker() + if resolved: + reflect_tracker_manager.remove_tracker(self.stream_id) + logger.info(f"{self.log_prefix} ReflectTracker resolved and removed.") + + start_time = time.time() async with global_prompt_manager.async_message_scope(self.chat_stream.context.get_template_name()): - asyncio.create_task(self.expression_learner.trigger_learning_for_chat()) - asyncio.create_task( - frequency_control_manager.get_or_create_frequency_control(self.stream_id).trigger_frequency_adjust() - ) + # 通过 MessageRecorder 统一提取消息并分发给 expression_learner 和 jargon_miner + # 在 replyer 执行时触发，统一管理时间窗口，避免重复获取消息 + asyncio.create_task(extract_and_distribute_messages(self.stream_id)) # 添加curious检测任务 - 检测聊天记录中的矛盾、冲突或需要提问的内容 # asyncio.create_task(check_and_make_question(self.stream_id)) - # 添加jargon提取任务 - 提取聊天中的黑话/俚语并入库（内部自行取消息并带冷却） - asyncio.create_task(extract_and_store_jargon(self.stream_id)) # 添加聊天内容概括任务 - 累积、打包和压缩聊天记录 # 注意：后台循环已在start()中启动，这里作为额外触发点，在有思考时立即处理 # asyncio.create_task(self.chat_history_summarizer.process()) cycle_timers, thinking_id = self.start_cycle() - logger.info(f"{self.log_prefix} 开始第{self._cycle_counter}次思考(频率: {global_config.chat.get_talk_value(self.stream_id)})") + logger.info( + f"{self.log_prefix} 开始第{self._cycle_counter}次思考(频率: {global_config.chat.get_talk_value(self.stream_id)})" + ) # 第一步：动作检查 available_actions: Dict[str, ActionInfo] = {} @@ -420,94 +334,50 @@ class HeartFChatting: except Exception as e: logger.error(f"{self.log_prefix} 动作修改失败: {e}") - # 如果被提及，让回复生成和planner并行执行 - if force_reply_message: - logger.info(f"{self.log_prefix} 检测到提及，回复生成与planner并行执行") + # 执行planner + is_group_chat, chat_target_info, _ = self.action_planner.get_necessary_info() - # 并行执行planner和回复生成 - planner_task = asyncio.create_task( - self._run_planner_without_reply( - available_actions=available_actions, - cycle_timers=cycle_timers, - ) + message_list_before_now = get_raw_msg_before_timestamp_with_chat( + chat_id=self.stream_id, + timestamp=time.time(), + limit=int(global_config.chat.max_context_size * 0.6), + filter_intercept_message_level=1, + ) + chat_content_block, message_id_list = build_readable_messages_with_id( + messages=message_list_before_now, + timestamp_mode="normal_no_YMD", + read_mark=self.action_planner.last_obs_time_mark, + truncate=True, + show_actions=True, + ) + + prompt_info = await self.action_planner.build_planner_prompt( + is_group_chat=is_group_chat, + chat_target_info=chat_target_info, + current_available_actions=available_actions, + chat_content_block=chat_content_block, + message_id_list=message_id_list, + ) + continue_flag, modified_message = await events_manager.handle_mai_events( + EventType.ON_PLAN, None, prompt_info[0], None, self.chat_stream.stream_id + ) + if not continue_flag: + return False + if modified_message and modified_message._modify_flags.modify_llm_prompt: + prompt_info = (modified_message.llm_prompt, prompt_info[1]) + + with Timer("规划器", cycle_timers): + action_to_use_info = await self.action_planner.plan( + loop_start_time=self.last_read_time, + available_actions=available_actions, + force_reply_message=force_reply_message, ) - reply_task = asyncio.create_task( - self._generate_mentioned_reply( - force_reply_message=force_reply_message, - thinking_id=thinking_id, - cycle_timers=cycle_timers, - available_actions=available_actions, - ) - ) - - # 等待两个任务完成 - planner_result, reply_result = await asyncio.gather(planner_task, reply_task, return_exceptions=True) - - # 处理planner结果 - if isinstance(planner_result, BaseException): - logger.error(f"{self.log_prefix} Planner执行异常: {planner_result}") - action_to_use_info = [] - else: - action_to_use_info = planner_result - - # 处理回复结果 - if isinstance(reply_result, BaseException): - logger.error(f"{self.log_prefix} 回复生成异常: {reply_result}") - reply_result = { - "action_type": "reply", - "success": False, - "result": "回复生成异常", - "loop_info": None, - } - else: - # 正常流程：只执行planner - is_group_chat, chat_target_info, _ = self.action_planner.get_necessary_info() - - message_list_before_now = get_raw_msg_before_timestamp_with_chat( - chat_id=self.stream_id, - timestamp=time.time(), - limit=int(global_config.chat.max_context_size * 0.6), - ) - chat_content_block, message_id_list = build_readable_messages_with_id( - messages=message_list_before_now, - timestamp_mode="normal_no_YMD", - read_mark=self.action_planner.last_obs_time_mark, - truncate=True, - show_actions=True, - ) - - prompt_info = await self.action_planner.build_planner_prompt( - is_group_chat=is_group_chat, - chat_target_info=chat_target_info, - current_available_actions=available_actions, - chat_content_block=chat_content_block, - message_id_list=message_id_list, - interest=global_config.personality.interest, - ) - continue_flag, modified_message = await events_manager.handle_mai_events( - EventType.ON_PLAN, None, prompt_info[0], None, self.chat_stream.stream_id - ) - if not continue_flag: - return False - if modified_message and modified_message._modify_flags.modify_llm_prompt: - prompt_info = (modified_message.llm_prompt, prompt_info[1]) - - with Timer("规划器", cycle_timers): - action_to_use_info = await self.action_planner.plan( - loop_start_time=self.last_read_time, - available_actions=available_actions, - ) - reply_result = None - - # 只在提及情况下过滤掉planner返回的reply动作（提及时已有独立回复生成） - if force_reply_message: - action_to_use_info = [action for action in action_to_use_info if action.action_type != "reply"] logger.info( f"{self.log_prefix} 决定执行{len(action_to_use_info)}个动作: {' '.join([a.action_type for a in action_to_use_info])}" ) - # 3. 并行执行所有动作（不包括reply，reply已经独立执行） + # 3. 并行执行所有动作 action_tasks = [ asyncio.create_task( self._execute_action(action, action_to_use_info, thinking_id, available_actions, cycle_timers) @@ -518,10 +388,6 @@ class HeartFChatting: # 并行执行所有任务 results = await asyncio.gather(*action_tasks, return_exceptions=True) - # 如果有独立的回复结果，添加到结果列表中 - if reply_result: - results = list(results) + [reply_result] - # 处理执行结果 reply_loop_info = None reply_text_from_reply = "" @@ -732,31 +598,6 @@ class HeartFChatting: 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 "选择不回复" - - # 增加连续 no_reply 计数 - self.consecutive_no_reply_count += 1 - self.no_reply_until_call = True - 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": # 直接当场执行reply逻辑 self.questioned = False @@ -765,8 +606,27 @@ class HeartFChatting: self.consecutive_no_reply_count = 0 reason = action_planner_info.reasoning or "" + # 根据 think_mode 配置决定 think_level 的值 + think_mode = global_config.chat.think_mode + if think_mode == "default": + think_level = 0 + elif think_mode == "deep": + think_level = 1 + elif think_mode == "dynamic": + # dynamic 模式：从 planner 返回的 action_data 中获取 + think_level = action_planner_info.action_data.get("think_level", 1) + else: + # 默认使用 default 模式 + think_level = 0 # 使用 action_reasoning（planner 的整体思考理由）作为 reply_reason planner_reasoning = action_planner_info.action_reasoning or reason + + record_replyer_action_temp( + chat_id=self.stream_id, + reason=reason, + think_level=think_level, + ) + await database_api.store_action_info( chat_stream=self.chat_stream, action_build_into_prompt=False, @@ -778,16 +638,32 @@ class HeartFChatting: action_reasoning=reason, ) + # 从 Planner 的 action_data 中提取未知词语列表（仅在 reply 时使用） + unknown_words = None + if isinstance(action_planner_info.action_data, dict): + uw = action_planner_info.action_data.get("unknown_words") + if isinstance(uw, list): + cleaned_uw: List[str] = [] + for item in uw: + if isinstance(item, str): + s = item.strip() + if s: + cleaned_uw.append(s) + if cleaned_uw: + unknown_words = cleaned_uw + 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=planner_reasoning, + unknown_words=unknown_words, 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()), + think_level=think_level, ) if not success or not llm_response or not llm_response.reply_set: @@ -814,6 +690,7 @@ class HeartFChatting: "result": f"你回复内容{reply_text}", "loop_info": loop_info, } + else: # 执行普通动作 with Timer("动作执行", cycle_timers): diff --git a/src/chat/heart_flow/heartflow_message_processor.py b/src/chat/heart_flow/heartflow_message_processor.py index d0e1f9c9..09a3a94d 100644 --- a/src/chat/heart_flow/heartflow_message_processor.py +++ b/src/chat/heart_flow/heartflow_message_processor.py @@ -39,6 +39,11 @@ class HeartFCMessageReceiver: message_data: 原始消息字符串 """ try: + # 通知消息不处理 + if message.is_notify: + logger.debug("通知消息，跳过处理") + return + # 1. 消息解析与初始化 userinfo = message.message_info.user_info chat = message.chat_stream diff --git a/src/chat/knowledge/__init__.py b/src/chat/knowledge/__init__.py index a570277c..57e94472 100644 --- a/src/chat/knowledge/__init__.py +++ b/src/chat/knowledge/__init__.py @@ -42,7 +42,10 @@ def lpmm_start_up(): # sourcery skip: extract-duplicate-method logger.info("创建LLM客户端") # 初始化Embedding库 - embed_manager = EmbeddingManager() + embed_manager = EmbeddingManager( + max_workers=global_config.lpmm_knowledge.max_embedding_workers, + chunk_size=global_config.lpmm_knowledge.embedding_chunk_size, + ) logger.info("正在从文件加载Embedding库") try: embed_manager.load_from_file() diff --git a/src/chat/knowledge/embedding_store.py b/src/chat/knowledge/embedding_store.py index 768373cf..9c460a0d 100644 --- a/src/chat/knowledge/embedding_store.py +++ b/src/chat/knowledge/embedding_store.py @@ -104,7 +104,9 @@ class EmbeddingStore: self.dir = dir_path self.embedding_file_path = f"{dir_path}/{namespace}.parquet" self.index_file_path = f"{dir_path}/{namespace}.index" - self.idx2hash_file_path = dir_path + "/" + namespace + "_i2h.json" + self.idx2hash_file_path = f"{dir_path}/{namespace}_i2h.json" + + self.dirty = False # 标记是否有新增数据需要重建索引 # 多线程配置参数验证和设置 self.max_workers = max(MIN_WORKERS, min(MAX_WORKERS, max_workers)) @@ -125,6 +127,11 @@ class EmbeddingStore: self.faiss_index = None self.idx2hash = None + @staticmethod + def hash_texts(namespace: str, texts: List[str]) -> List[str]: + """将原文计算为带前缀的键""" + return [f"{namespace}-{get_sha256(t)}" for t in texts] + def _get_embedding(self, s: str) -> List[float]: """获取字符串的嵌入向量，使用完全同步的方式避免事件循环问题""" # 创建新的事件循环并在完成后立即关闭 @@ -412,6 +419,7 @@ class EmbeddingStore: item_hash = self.namespace + "-" + get_sha256(s) if embedding: # 只有成功获取到嵌入才存入 self.store[item_hash] = EmbeddingStoreItem(item_hash, embedding, s) + self.dirty = True else: logger.warning(f"跳过存储失败的嵌入: {s[:50]}...") @@ -488,9 +496,17 @@ class EmbeddingStore: self.build_faiss_index() logger.info(f"{self.namespace}嵌入库的FaissIndex重建成功") self.save_to_file() + self.dirty = False def build_faiss_index(self) -> None: """重新构建Faiss索引，以余弦相似度为度量""" + # 空库直接跳过，清空索引映射 + if not self.store: + self.idx2hash = {} + self.faiss_index = None + self.dirty = False + return + # 获取所有的embedding array = [] self.idx2hash = dict() @@ -498,11 +514,44 @@ class EmbeddingStore: array.append(self.store[key].embedding) self.idx2hash[str(len(array) - 1)] = key embeddings = np.array(array, dtype=np.float32) + if embeddings.size == 0: + self.idx2hash = {} + self.faiss_index = None + self.dirty = False + return # L2归一化 faiss.normalize_L2(embeddings) # 构建索引 self.faiss_index = faiss.IndexFlatIP(global_config.lpmm_knowledge.embedding_dimension) self.faiss_index.add(embeddings) + self.dirty = False + + def delete_items(self, hashes: List[str]) -> Tuple[int, int]: + """删除指定键的嵌入并重建 idx2hash（不直接重建 faiss） + + Args: + hashes: 需要删除的完整键列表（如 paragraph-xxx） + + Returns: + (deleted, skipped) + """ + deleted = 0 + skipped = 0 + for h in hashes: + if h in self.store: + self.store.pop(h) + deleted += 1 + else: + skipped += 1 + + # 重新构建 idx2hash 映射 + self.idx2hash = {} + for idx, key in enumerate(self.store.keys()): + self.idx2hash[str(idx)] = key + + # 删除后标记 dirty，faiss 重建由上层统一调用 + self.dirty = True + return deleted, skipped def search_top_k(self, query: List[float], k: int) -> List[Tuple[str, float]]: """搜索最相似的k个项，以余弦相似度为度量 @@ -536,7 +585,7 @@ class EmbeddingStore: class EmbeddingManager: - def __init__(self, max_workers: int = DEFAULT_MAX_WORKERS, chunk_size: int = DEFAULT_CHUNK_SIZE): + def __init__(self, max_workers: int | None = None, chunk_size: int | None = None): """ 初始化EmbeddingManager @@ -544,6 +593,8 @@ class EmbeddingManager: max_workers: 最大线程数 chunk_size: 每个线程处理的数据块大小 """ + max_workers = max_workers if max_workers is not None else global_config.lpmm_knowledge.max_embedding_workers + chunk_size = chunk_size if chunk_size is not None else global_config.lpmm_knowledge.embedding_chunk_size self.paragraphs_embedding_store = EmbeddingStore( "paragraph", # type: ignore EMBEDDING_DATA_DIR_STR, @@ -617,7 +668,19 @@ class EmbeddingManager: self.relation_embedding_store.save_to_file() def rebuild_faiss_index(self): - """重建Faiss索引（请在添加新数据后调用）""" - self.paragraphs_embedding_store.build_faiss_index() - self.entities_embedding_store.build_faiss_index() - self.relation_embedding_store.build_faiss_index() + """重建Faiss索引，新增数据后调用，带跳过逻辑""" + + def _rebuild_if_needed(store: EmbeddingStore): + if ( + not store.dirty + and store.faiss_index is not None + and store.idx2hash is not None + and getattr(store.faiss_index, "ntotal", 0) == len(store.idx2hash) == len(store.store) + ): + logger.info(f"{store.namespace} FaissIndex 已是最新，跳过重建") + return + store.build_faiss_index() + + _rebuild_if_needed(self.paragraphs_embedding_store) + _rebuild_if_needed(self.entities_embedding_store) + _rebuild_if_needed(self.relation_embedding_store) diff --git a/src/chat/knowledge/kg_manager.py b/src/chat/knowledge/kg_manager.py index ac86fa20..8108c296 100644 --- a/src/chat/knowledge/kg_manager.py +++ b/src/chat/knowledge/kg_manager.py @@ -1,7 +1,8 @@ import json import os import time -from typing import Dict, List, Tuple +from typing import Dict, List, Tuple, Set +import xml.etree.ElementTree as ET import numpy as np import pandas as pd @@ -98,6 +99,28 @@ class KGManager: # 加载KG self.graph = di_graph.load_from_file(self.graph_data_path) + def _rebuild_metadata_from_graph(self) -> None: + """根据当前图重建 stored_paragraph_hashes 与 ent_appear_cnt""" + nodes = self.graph.get_node_list() + edges = self.graph.get_edge_list() + + # 段落 hash：paragraph-{hash} + self.stored_paragraph_hashes = set() + for node_id in nodes: + if node_id.startswith("paragraph-"): + self.stored_paragraph_hashes.add(node_id.split("paragraph-", 1)[1]) + + # 实体出现次数：基于 entity -> paragraph 的边权 + ent_appear_cnt: Dict[str, float] = {} + for edge_tuple in edges: + src, tgt = edge_tuple[0], edge_tuple[1] + if src.startswith("entity") and tgt.startswith("paragraph"): + edge_data = self.graph[src, tgt] + weight = edge_data["weight"] if "weight" in edge_data else 1.0 + ent_appear_cnt[src] = ent_appear_cnt.get(src, 0.0) + float(weight) + + self.ent_appear_cnt = ent_appear_cnt + def _build_edges_between_ent( self, node_to_node: Dict[Tuple[str, str], float], @@ -149,6 +172,13 @@ class KGManager: ent_hash_list.add("entity" + "-" + get_sha256(triple[0])) ent_hash_list.add("entity" + "-" + get_sha256(triple[2])) ent_hash_list = list(ent_hash_list) + # 性能保护：限制同义连接的实体数量 + max_synonym_entities = global_config.lpmm_knowledge.max_synonym_entities + if max_synonym_entities and len(ent_hash_list) > max_synonym_entities: + logger.warning( + f"同义连接实体数 {len(ent_hash_list)} 超过阈值 {max_synonym_entities}，跳过同义边构建以保护性能" + ) + return 0 synonym_hash_set = set() synonym_result = {} @@ -328,6 +358,10 @@ class KGManager: paragraph_search_result: ParagraphEmbedding的搜索结果（paragraph_hash, similarity） embed_manager: EmbeddingManager对象 """ + # 性能保护：关闭时直接返回向量检索结果 + if not global_config.lpmm_knowledge.enable_ppr: + logger.info("PPR 已禁用，使用纯向量检索结果") + return paragraph_search_result, None # 图中存在的节点总集 existed_nodes = self.graph.get_node_list() @@ -357,7 +391,15 @@ class KGManager: ent_mean_scores = {} # 记录实体的平均相似度 for ent_hash, scores in ent_sim_scores.items(): # 先对相似度进行累加，然后与实体计数相除获取最终权重 - ent_weights[ent_hash] = float(np.sum(scores)) / self.ent_appear_cnt[ent_hash] + # 保护：有些实体在当前图中可能只有实体-实体关系，不会出现在 ent_appear_cnt 中 + appear_cnt = self.ent_appear_cnt.get(ent_hash) + if not appear_cnt or appear_cnt <= 0: + logger.debug( + f"实体 {ent_hash} 在 ent_appear_cnt 中不存在或计数为 0，" + f"将使用 1.0 作为默认出现次数参与权重计算" + ) + appear_cnt = 1.0 + ent_weights[ent_hash] = float(np.sum(scores)) / float(appear_cnt) # 记录实体的平均相似度，用于后续的top_k筛选 ent_mean_scores[ent_hash] = float(np.mean(scores)) del ent_sim_scores @@ -434,3 +476,115 @@ class KGManager: passage_node_res = sorted(passage_node_res, key=lambda item: item[1], reverse=True) return passage_node_res, ppr_node_weights + + def delete_paragraphs( + self, + pg_hashes: List[str], + ent_hashes: List[str] | None = None, + remove_orphan_entities: bool = False, + ) -> Dict[str, int]: + """删除段落/实体节点及相关边（基于 GraphML），可选清理孤立实体，并重建元数据""" + # 要删除的节点 ID + nodes_to_delete: Set[str] = {f"paragraph-{h}" for h in pg_hashes} + if ent_hashes: + nodes_to_delete.update({f"entity-{h}" for h in ent_hashes}) + + if not os.path.exists(self.graph_data_path): + raise FileNotFoundError(f"KG图文件{self.graph_data_path}不存在") + + tree = ET.parse(self.graph_data_path) + root = tree.getroot() + + # GraphML 可能带命名空间，用尾缀判断 + def is_node(elem: ET.Element) -> bool: + return elem.tag.endswith("node") + + def is_edge(elem: ET.Element) -> bool: + return elem.tag.endswith("edge") + + graph_elem = None + for child in root: + if child.tag.endswith("graph"): + graph_elem = child + break + if graph_elem is None: + raise RuntimeError("GraphML 中未找到 节点") + + # 统计现有节点 + existing_nodes: Set[str] = set() + for elem in graph_elem: + if is_node(elem): + node_id = elem.get("id") + if node_id: + existing_nodes.add(node_id) + + deleted_nodes = len(nodes_to_delete & existing_nodes) + skipped_nodes = len(nodes_to_delete - existing_nodes) + + # 先删除指定节点及相关边 + # 删除节点 + for elem in list(graph_elem): + if is_node(elem): + node_id = elem.get("id") + if node_id and node_id in nodes_to_delete: + graph_elem.remove(elem) + + # 删除 incident edges + for elem in list(graph_elem): + if is_edge(elem): + src = elem.get("source") + tgt = elem.get("target") + if src in nodes_to_delete or tgt in nodes_to_delete: + graph_elem.remove(elem) + + orphan_removed = 0 + if remove_orphan_entities: + # 计算仍然参与边的节点 + used_nodes: Set[str] = set() + for elem in graph_elem: + if is_edge(elem): + src = elem.get("source") + tgt = elem.get("target") + if src: + used_nodes.add(src) + if tgt: + used_nodes.add(tgt) + + # 找出没有任何边的实体节点 + orphan_entities: Set[str] = set() + for elem in graph_elem: + if is_node(elem): + node_id = elem.get("id") + if node_id and node_id.startswith("entity") and node_id not in used_nodes: + orphan_entities.add(node_id) + + orphan_removed = len(orphan_entities) + + if orphan_entities: + # 删除孤立实体节点 + for elem in list(graph_elem): + if is_node(elem): + node_id = elem.get("id") + if node_id in orphan_entities: + graph_elem.remove(elem) + + # 删除与孤立实体相关的边（理论上已无，但做一次防御性清理） + for elem in list(graph_elem): + if is_edge(elem): + src = elem.get("source") + tgt = elem.get("target") + if src in orphan_entities or tgt in orphan_entities: + graph_elem.remove(elem) + + # 写回 GraphML + tree.write(self.graph_data_path, encoding="utf-8", xml_declaration=True) + + # 重新加载图并重建元数据 + self.graph = di_graph.load_from_file(self.graph_data_path) + self._rebuild_metadata_from_graph() + + return { + "deleted": deleted_nodes, + "skipped": skipped_nodes, + "orphan_removed": orphan_removed, + } diff --git a/src/chat/message_receive/bot.py b/src/chat/message_receive/bot.py index 070f78bd..c45ec105 100644 --- a/src/chat/message_receive/bot.py +++ b/src/chat/message_receive/bot.py @@ -7,7 +7,6 @@ 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 from src.chat.message_receive.message import MessageRecv from src.chat.message_receive.storage import MessageStorage @@ -73,7 +72,6 @@ class ChatBot: def __init__(self): self.bot = None # bot 实例引用 self._started = False - self.mood_manager = mood_manager # 获取情绪管理器单例 self.heartflow_message_receiver = HeartFCMessageReceiver() # 新增 async def _ensure_started(self): @@ -83,7 +81,7 @@ class ChatBot: self._started = True - async def _process_commands_with_new_system(self, message: MessageRecv): + async def _process_commands(self, message: MessageRecv): # sourcery skip: use-named-expression """使用新插件系统处理命令""" try: @@ -115,16 +113,21 @@ class ChatBot: try: # 执行命令 - success, response, intercept_message = await command_instance.execute() + success, response, intercept_message_level = await command_instance.execute() + message.intercept_message_level = intercept_message_level # 记录命令执行结果 if success: - logger.info(f"命令执行成功: {command_class.__name__} (拦截: {intercept_message})") + logger.info(f"命令执行成功: {command_class.__name__} (拦截等级: {intercept_message_level})") else: logger.warning(f"命令执行失败: {command_class.__name__} - {response}") # 根据命令的拦截设置决定是否继续处理消息 - return True, response, not intercept_message # 找到命令，根据intercept_message决定是否继续 + return ( + True, + response, + not bool(intercept_message_level), + ) # 找到命令，根据intercept_message决定是否继续 except Exception as e: logger.error(f"执行命令时出错: {command_class.__name__} - {e}") @@ -294,7 +297,7 @@ class ChatBot: # return # 命令处理 - 使用新插件系统检查并处理命令 - is_command, cmd_result, continue_process = await self._process_commands_with_new_system(message) + is_command, cmd_result, continue_process = await self._process_commands(message) # 如果是命令且不需要继续处理，则直接返回 if is_command and not continue_process: diff --git a/src/chat/message_receive/message.py b/src/chat/message_receive/message.py index 6c1ec1a7..d093e07e 100644 --- a/src/chat/message_receive/message.py +++ b/src/chat/message_receive/message.py @@ -122,6 +122,7 @@ class MessageRecv(Message): self.is_notify = False self.is_command = False + self.intercept_message_level = 0 self.priority_mode = "interest" self.priority_info = None @@ -212,6 +213,68 @@ class MessageRecv(Message): } """ return "" + elif segment.type == "video_card": + # 处理视频卡片消息 + self.is_picid = False + self.is_emoji = False + self.is_voice = False + if isinstance(segment.data, dict): + file_name = segment.data.get("file", "未知视频") + file_size = segment.data.get("file_size", "") + url = segment.data.get("url", "") + text = f"[视频: {file_name}" + if file_size: + text += f", 大小: {file_size}字节" + text += "]" + if url: + text += f" 链接: {url}" + return text + return "[视频]" + elif segment.type == "music_card": + # 处理音乐卡片消息 + self.is_picid = False + self.is_emoji = False + self.is_voice = False + if isinstance(segment.data, dict): + title = segment.data.get("title", "未知歌曲") + singer = segment.data.get("singer", "") + tag = segment.data.get("tag", "") # 音乐来源，如"网易云音乐" + jump_url = segment.data.get("jump_url", "") + music_url = segment.data.get("music_url", "") + text = f"[音乐: {title}" + if singer: + text += f" - {singer}" + if tag: + text += f" ({tag})" + text += "]" + if jump_url: + text += f" 跳转链接: {jump_url}" + if music_url: + text += f" 音乐链接: {music_url}" + return text + return "[音乐]" + elif segment.type == "miniapp_card": + # 处理小程序分享卡片（如B站视频分享） + self.is_picid = False + self.is_emoji = False + self.is_voice = False + if isinstance(segment.data, dict): + title = segment.data.get("title", "") # 小程序名称 + desc = segment.data.get("desc", "") # 内容描述 + source_url = segment.data.get("source_url", "") # 原始链接 + url = segment.data.get("url", "") # 小程序链接 + text = "[小程序分享" + if title: + text += f" - {title}" + text += "]" + if desc: + text += f" {desc}" + if source_url: + text += f" 链接: {source_url}" + elif url: + text += f" 链接: {url}" + return text + return "[小程序分享]" else: return "" except Exception as e: diff --git a/src/chat/message_receive/storage.py b/src/chat/message_receive/storage.py index 2abf4ce2..b73b04a3 100644 --- a/src/chat/message_receive/storage.py +++ b/src/chat/message_receive/storage.py @@ -33,6 +33,11 @@ class MessageStorage: async def store_message(message: Union[MessageSending, MessageRecv], chat_stream: ChatStream) -> None: """存储消息到数据库""" try: + # 通知消息不存储 + if isinstance(message, MessageRecv) and message.is_notify: + logger.debug("通知消息，跳过存储") + return + pattern = r".*?|.*?|.*?" # print(message) @@ -67,6 +72,7 @@ class MessageStorage: key_words = "" key_words_lite = "" selected_expressions = message.selected_expressions + intercept_message_level = 0 else: filtered_display_message = "" interest_value = message.interest_value @@ -80,6 +86,7 @@ class MessageStorage: is_picid = message.is_picid is_notify = message.is_notify is_command = message.is_command + intercept_message_level = getattr(message, "intercept_message_level", 0) # 序列化关键词列表为JSON字符串 key_words = MessageStorage._serialize_keywords(message.key_words) key_words_lite = MessageStorage._serialize_keywords(message.key_words_lite) @@ -131,6 +138,7 @@ class MessageStorage: is_picid=is_picid, is_notify=is_notify, is_command=is_command, + intercept_message_level=intercept_message_level, key_words=key_words, key_words_lite=key_words_lite, selected_expressions=selected_expressions, diff --git a/src/chat/message_receive/uni_message_sender.py b/src/chat/message_receive/uni_message_sender.py index 5a8ae022..b0a328e1 100644 --- a/src/chat/message_receive/uni_message_sender.py +++ b/src/chat/message_receive/uni_message_sender.py @@ -15,17 +15,237 @@ install(extra_lines=3) logger = get_logger("sender") +# WebUI 聊天室的消息广播器（延迟导入避免循环依赖） +_webui_chat_broadcaster = None + +# 虚拟群 ID 前缀（与 chat_routes.py 保持一致） +VIRTUAL_GROUP_ID_PREFIX = "webui_virtual_group_" + + +def get_webui_chat_broadcaster(): + """获取 WebUI 聊天室广播器""" + global _webui_chat_broadcaster + if _webui_chat_broadcaster is None: + try: + from src.webui.chat_routes import chat_manager, WEBUI_CHAT_PLATFORM + + _webui_chat_broadcaster = (chat_manager, WEBUI_CHAT_PLATFORM) + except ImportError: + _webui_chat_broadcaster = (None, None) + return _webui_chat_broadcaster + + +def is_webui_virtual_group(group_id: str) -> bool: + """检查是否是 WebUI 虚拟群""" + return group_id and group_id.startswith(VIRTUAL_GROUP_ID_PREFIX) + + +def parse_message_segments(segment) -> list: + """解析消息段，转换为 WebUI 可用的格式 + + 参考 NapCat 适配器的消息解析逻辑 + + Args: + segment: Seg 消息段对象 + + Returns: + list: 消息段列表，每个元素为 {"type": "...", "data": ...} + """ + + result = [] + + if segment is None: + return result + + if segment.type == "seglist": + # 处理消息段列表 + if segment.data: + for seg in segment.data: + result.extend(parse_message_segments(seg)) + elif segment.type == "text": + # 文本消息 + if segment.data: + result.append({"type": "text", "data": segment.data}) + elif segment.type == "image": + # 图片消息（base64） + if segment.data: + result.append({"type": "image", "data": f"data:image/png;base64,{segment.data}"}) + elif segment.type == "emoji": + # 表情包消息（base64） + if segment.data: + result.append({"type": "emoji", "data": f"data:image/gif;base64,{segment.data}"}) + elif segment.type == "imageurl": + # 图片链接消息 + if segment.data: + result.append({"type": "image", "data": segment.data}) + elif segment.type == "face": + # 原生表情 + result.append({"type": "face", "data": segment.data}) + elif segment.type == "voice": + # 语音消息（base64） + if segment.data: + result.append({"type": "voice", "data": f"data:audio/wav;base64,{segment.data}"}) + elif segment.type == "voiceurl": + # 语音链接 + if segment.data: + result.append({"type": "voice", "data": segment.data}) + elif segment.type == "video": + # 视频消息（base64） + if segment.data: + result.append({"type": "video", "data": f"data:video/mp4;base64,{segment.data}"}) + elif segment.type == "videourl": + # 视频链接 + if segment.data: + result.append({"type": "video", "data": segment.data}) + elif segment.type == "music": + # 音乐消息 + result.append({"type": "music", "data": segment.data}) + elif segment.type == "file": + # 文件消息 + result.append({"type": "file", "data": segment.data}) + elif segment.type == "reply": + # 回复消息 + result.append({"type": "reply", "data": segment.data}) + elif segment.type == "forward": + # 转发消息 + forward_items = [] + if segment.data: + for item in segment.data: + forward_items.append( + { + "content": parse_message_segments(item.get("message_segment", {})) + if isinstance(item, dict) + else [] + } + ) + result.append({"type": "forward", "data": forward_items}) + else: + # 未知类型，尝试作为文本处理 + if segment.data: + result.append({"type": "unknown", "original_type": segment.type, "data": str(segment.data)}) + + return result + async def _send_message(message: MessageSending, show_log=True) -> bool: """合并后的消息发送函数，包含WS发送和日志记录""" message_preview = truncate_message(message.processed_plain_text, max_length=200) + platform = message.message_info.platform + group_id = message.message_info.group_info.group_id if message.message_info.group_info else None try: - # 直接调用API发送消息 - await get_global_api().send_message(message) - if show_log: - logger.info(f"已将消息 '{message_preview}' 发往平台'{message.message_info.platform}'") - return True + # 检查是否是 WebUI 平台的消息，或者是 WebUI 虚拟群的消息 + chat_manager, webui_platform = get_webui_chat_broadcaster() + is_webui_message = (platform == webui_platform) or is_webui_virtual_group(group_id) + + if is_webui_message and chat_manager is not None: + # WebUI 聊天室消息（包括虚拟身份模式），通过 WebSocket 广播 + import time + from src.config.config import global_config + + # 解析消息段，获取富文本内容 + message_segments = parse_message_segments(message.message_segment) + + # 判断消息类型 + # 如果只有一个文本段，使用简单的 text 类型 + # 否则使用 rich 类型，包含完整的消息段 + if len(message_segments) == 1 and message_segments[0].get("type") == "text": + message_type = "text" + segments = None + else: + message_type = "rich" + segments = message_segments + + await chat_manager.broadcast( + { + "type": "bot_message", + "content": message.processed_plain_text, + "message_type": message_type, + "segments": segments, # 富文本消息段 + "timestamp": time.time(), + "group_id": group_id, # 包含群 ID 以便前端区分不同的聊天标签 + "sender": { + "name": global_config.bot.nickname, + "avatar": None, + "is_bot": True, + }, + } + ) + + # 注意：机器人消息会由 MessageStorage.store_message 自动保存到数据库 + # 无需手动保存 + + if show_log: + if is_webui_virtual_group(group_id): + logger.info(f"已将消息 '{message_preview}' 发往 WebUI 虚拟群 (平台: {platform})") + else: + logger.info(f"已将消息 '{message_preview}' 发往 WebUI 聊天室") + return True + + # Fallback 逻辑: 尝试通过 API Server 发送 + async def send_with_new_api(legacy_exception=None): + try: + from src.config.config import global_config + + # 如果未开启 API Server，直接跳过 Fallback + if not global_config.maim_message.enable_api_server: + if legacy_exception: + raise legacy_exception + return False + + global_api = get_global_api() + extra_server = getattr(global_api, "extra_server", None) + + if extra_server and extra_server.is_running(): + # Fallback: 使用极其简单的 Platform -> API Key 映射 + # 只有收到过该平台的消息，我们才知道该平台的 API Key，才能回传消息 + platform_map = getattr(global_api, "platform_map", {}) + target_api_key = platform_map.get(platform) + + if target_api_key: + # 构造 APIMessageBase + from maim_message.message import APIMessageBase, MessageDim + + msg_dim = MessageDim(api_key=target_api_key, platform=platform) + + api_message = APIMessageBase( + message_info=message.message_info, + message_segment=message.message_segment, + message_dim=msg_dim, + ) + + # 直接调用 Server 的 send_message 接口，它会自动处理路由 + results = await extra_server.send_message(api_message) + + # 检查是否有任何连接发送成功 + if any(results.values()): + if show_log: + logger.info( + f"已通过API Server Fallback将消息 '{message_preview}' 发往平台'{platform}' (key: {target_api_key})" + ) + return True + except Exception: + pass + + # 如果 Fallback 失败，且存在 legacy 异常，则抛出 legacy 异常 + if legacy_exception: + raise legacy_exception + return False + + try: + send_result = await get_global_api().send_message(message) + # if send_result: + if show_log: + logger.info(f"已将消息 '{message_preview}' 发往平台'{message.message_info.platform}'") + return True + + # Legacy API 返回 False (发送失败但未报错)，尝试 Fallback + # return await send_with_new_api() + + except Exception as legacy_e: + # Legacy API 抛出异常，尝试 Fallback + # 如果 Fallback 也失败，将重新抛出 legacy_e + return await send_with_new_api(legacy_exception=legacy_e) except Exception as e: logger.error(f"发送消息 '{message_preview}' 发往平台'{message.message_info.platform}' 失败: {str(e)}") diff --git a/src/chat/planner_actions/action_modifier.py b/src/chat/planner_actions/action_modifier.py index def8322a..baf1e1c5 100644 --- a/src/chat/planner_actions/action_modifier.py +++ b/src/chat/planner_actions/action_modifier.py @@ -69,6 +69,7 @@ class ActionModifier: chat_id=self.chat_stream.stream_id, timestamp=time.time(), limit=min(int(global_config.chat.max_context_size * 0.33), 10), + filter_intercept_message_level=1, ) chat_content = build_readable_messages( diff --git a/src/chat/planner_actions/planner.py b/src/chat/planner_actions/planner.py index 5771feed..645ee003 100644 --- a/src/chat/planner_actions/planner.py +++ b/src/chat/planner_actions/planner.py @@ -15,12 +15,15 @@ from src.chat.utils.prompt_builder import Prompt, global_prompt_manager from src.chat.utils.chat_message_builder import ( build_readable_messages_with_id, get_raw_msg_before_timestamp_with_chat, + replace_user_references, ) from src.chat.utils.utils import get_chat_type_and_target_info from src.chat.planner_actions.action_manager import ActionManager from src.chat.message_receive.chat_stream import get_chat_manager from src.plugin_system.base.component_types import ActionInfo, ComponentType, ActionActivationType from src.plugin_system.core.component_registry import component_registry +from src.plugin_system.apis.message_api import translate_pid_to_description +from src.person_info.person_info import Person if TYPE_CHECKING: from src.common.data_models.info_data_model import TargetPersonInfo @@ -36,7 +39,6 @@ def init_prompt(): """ {time_block} {name_block} -你的兴趣是：{interest} {chat_context_description}，以下是具体的聊天内容 **聊天内容** {chat_content_block} @@ -46,9 +48,12 @@ reply 动作描述： 1.你可以选择呼叫了你的名字，但是你没有做出回应的消息进行回复 2.你可以自然的顺着正在进行的聊天内容进行回复或自然的提出一个问题 -3.不要回复你自己发送的消息 -4.不要单独对表情包进行回复 -{{"action":"reply", "target_message_id":"消息id(m+数字)", "reason":"原因"}} +3.最好一次对一个话题进行回复，免得啰嗦或者回复内容太乱。 +4.不要选择回复你自己发送的消息 +5.不要单独对表情包进行回复 +6.将上下文中所有含义不明的，疑似黑话的，缩写词均写入unknown_words中 +7.用一句简单的话来描述当前回复场景，不超过10个字 +{reply_action_example} no_reply 动作描述： @@ -56,75 +61,37 @@ no_reply 控制聊天频率，不要太过频繁的发言 {{"action":"no_reply"}} -{no_reply_until_call_block} - {action_options_text} - **你之前的action执行和思考记录** {actions_before_now_block} 请选择**可选的**且符合使用条件的action，并说明触发action的消息id(消息id格式:m+数字) -不要回复你自己发送的消息 先输出你的简短的选择思考理由，再输出你选择的action，理由不要分点，精简。 **动作选择要求** 请你根据聊天内容,用户的最新消息和以下标准选择合适的动作: {plan_style} {moderation_prompt} -请选择所有符合使用要求的action，动作用json格式输出，用```json包裹，如果输出多个json，每个json都要单独一行放在同一个```json代码块内，你可以重复使用同一个动作或不同动作: +target_message_id为必填，表示触发消息的id +请选择所有符合使用要求的action，每个动作最多选择一次，但是可以选择多个动作； +动作用json格式输出，用```json包裹，如果输出多个json，每个json都要单独一行放在同一个```json代码块内: **示例** // 理由文本（简短） ```json -{{"action":"动作名", "target_message_id":"m123", "reason":"原因"}} -{{"action":"动作名", "target_message_id":"m456", "reason":"原因"}} +{{"action":"动作名", "target_message_id":"m123", .....}} +{{"action":"动作名", "target_message_id":"m456", .....}} ```""", "planner_prompt", ) - Prompt( - """{time_block} -{name_block} -{chat_context_description}，以下是具体的聊天内容 -**聊天内容** -{chat_content_block} - -**可选的action** -no_reply -动作描述： -没有合适的可以使用的动作，不使用action -{{"action":"no_reply"}} - -{action_options_text} - -**你之前的action执行和思考记录** -{actions_before_now_block} - -请选择**可选的**且符合使用条件的action，并说明触发action的消息id(消息id格式:m+数字) -先输出你的简短的选择思考理由，再输出你选择的action，理由不要分点，精简。 -**动作选择要求** -请你根据聊天内容,用户的最新消息和以下标准选择合适的动作: -1.思考**所有**的可用的action中的**每个动作**是否符合当下条件，如果动作使用条件符合聊天内容就使用 -2.如果相同的内容已经被执行，请不要重复执行 -{moderation_prompt} - -请选择所有符合使用要求的action，动作用json格式输出，用```json包裹，如果输出多个json，每个json都要单独一行放在同一个```json代码块内，你可以重复使用同一个动作或不同动作: -**示例** -// 理由文本（简短） -```json -{{"action":"动作名", "target_message_id":"m123", "reason":"原因"}} -{{"action":"动作名", "target_message_id":"m456", "reason":"原因"}} -```""", - "planner_prompt_mentioned", - ) - Prompt( """ {action_name} 动作描述：{action_description} 使用条件{parallel_text}： {action_require} -{{"action":"{action_name}",{action_parameters}, "target_message_id":"消息id(m+数字)", "reason":"原因"}} +{{"action":"{action_name}",{action_parameters}, "target_message_id":"消息id(m+数字)"}} """, "action_prompt", ) @@ -181,8 +148,12 @@ class ActionPlanner: found_ids = set(matches) missing_ids = found_ids - available_ids if missing_ids: - logger.info(f"{self.log_prefix}planner理由中引用的消息ID不在当前上下文中: {missing_ids}, 可用ID: {list(available_ids)[:10]}...") - logger.info(f"{self.log_prefix}planner理由替换: 找到{len(matches)}个消息ID引用，其中{len(found_ids & available_ids)}个在上下文中") + logger.info( + f"{self.log_prefix}planner理由中引用的消息ID不在当前上下文中: {missing_ids}, 可用ID: {list(available_ids)[:10]}..." + ) + logger.info( + f"{self.log_prefix}planner理由替换: 找到{len(matches)}个消息ID引用，其中{len(found_ids & available_ids)}个在上下文中" + ) def _replace(match: re.Match[str]) -> str: msg_id = match.group(0) @@ -191,11 +162,41 @@ class ActionPlanner: logger.warning(f"{self.log_prefix}planner理由引用 {msg_id} 未找到对应消息，保持原样") return msg_id - msg_text = (message.processed_plain_text or message.display_message or "").strip() + msg_text = (message.processed_plain_text or "").strip() if not msg_text: logger.warning(f"{self.log_prefix}planner理由引用 {msg_id} 的消息内容为空，保持原样") return msg_id + # 替换 [picid:xxx] 为 [图片：描述] + pic_pattern = r"\[picid:([^\]]+)\]" + def replace_pic_id(pic_match: re.Match) -> str: + pic_id = pic_match.group(1) + description = translate_pid_to_description(pic_id) + return f"[图片：{description}]" + msg_text = re.sub(pic_pattern, replace_pic_id, msg_text) + + # 替换用户引用格式：回复 和 @ + platform = getattr(message, "user_info", None) and message.user_info.platform or getattr(message, "chat_info", None) and message.chat_info.platform or "qq" + msg_text = replace_user_references(msg_text, platform, replace_bot_name=True) + + # 替换单独的 <用户名:用户ID> 格式（replace_user_references 已处理回复<和@<格式） + # 匹配所有 格式，由于 replace_user_references 已经替换了回复<和@<格式， + # 这里匹配到的应该都是单独的格式 + user_ref_pattern = r"<([^:<>]+):([^:<>]+)>" + def replace_user_ref(user_match: re.Match) -> str: + user_name = user_match.group(1) + user_id = user_match.group(2) + try: + # 检查是否是机器人自己 + if user_id == global_config.bot.qq_account: + return f"{global_config.bot.nickname}(你)" + person = Person(platform=platform, user_id=user_id) + return person.person_name or user_name + except Exception: + # 如果解析失败，使用原始昵称 + return user_name + msg_text = re.sub(user_ref_pattern, replace_user_ref, msg_text) + preview = msg_text if len(msg_text) <= 100 else f"{msg_text[:97]}..." logger.info(f"{self.log_prefix}planner理由引用 {msg_id} -> 消息（{preview}）") return f"消息（{msg_text}）" @@ -214,15 +215,19 @@ class ActionPlanner: try: action = action_json.get("action", "no_reply") - original_reasoning = action_json.get("reason", "未提供原因") - reasoning = self._replace_message_ids_with_text(original_reasoning, message_id_list) - if reasoning is None: - reasoning = original_reasoning - action_data = {key: value for key, value in action_json.items() if key not in ["action", "reason"]} + # 使用 extracted_reasoning（整体推理文本）作为 reasoning + if extracted_reasoning: + reasoning = self._replace_message_ids_with_text(extracted_reasoning, message_id_list) + if reasoning is None: + reasoning = extracted_reasoning + else: + reasoning = "未提供原因" + action_data = {key: value for key, value in action_json.items() if key not in ["action"]} # 非no_reply动作需要target_message_id target_message = None - if target_message_id := action_json.get("target_message_id"): + target_message_id = action_json.get("target_message_id") + if target_message_id: # 根据target_message_id查找原始消息 target_message = self.find_message_by_id(target_message_id, message_id_list) if target_message is None: @@ -233,9 +238,17 @@ class ActionPlanner: target_message = message_id_list[-1][1] logger.debug(f"{self.log_prefix}动作'{action}'缺少target_message_id，使用最新消息作为target_message") + if action != "no_reply" and target_message is not None and self._is_message_from_self(target_message): + logger.info( + f"{self.log_prefix}Planner选择了自己的消息 {target_message_id or target_message.message_id} 作为目标，强制使用 no_reply" + ) + reasoning = f"目标消息 {target_message_id or target_message.message_id} 来自机器人自身，违反不回复自身消息规则。原始理由: {reasoning}" + action = "no_reply" + target_message = None + # 验证action是否可用 available_action_names = [action_name for action_name, _ in current_available_actions] - internal_action_names = ["no_reply", "reply", "wait_time", "no_reply_until_call"] + internal_action_names = ["no_reply", "reply", "wait_time"] if action not in internal_action_names and action not in available_action_names: logger.warning( @@ -277,11 +290,21 @@ class ActionPlanner: return action_planner_infos + def _is_message_from_self(self, message: "DatabaseMessages") -> bool: + """判断消息是否由机器人自身发送""" + try: + return str(message.user_info.user_id) == str(global_config.bot.qq_account) and ( + message.user_info.platform or "" + ) == (global_config.bot.platform or "") + except AttributeError: + logger.warning(f"{self.log_prefix}检测消息发送者失败，缺少必要字段") + return False + async def plan( self, available_actions: Dict[str, ActionInfo], loop_start_time: float = 0.0, - is_mentioned: bool = False, + force_reply_message: Optional["DatabaseMessages"] = None, ) -> List[ActionPlannerInfo]: # sourcery skip: use-named-expression """ @@ -293,6 +316,7 @@ class ActionPlanner: chat_id=self.chat_id, timestamp=time.time(), limit=int(global_config.chat.max_context_size * 0.6), + filter_intercept_message_level=1, ) message_id_list: list[Tuple[str, "DatabaseMessages"]] = [] chat_content_block, message_id_list = build_readable_messages_with_id( @@ -321,11 +345,6 @@ class ActionPlanner: logger.debug(f"{self.log_prefix}过滤后有{len(filtered_actions)}个可用动作") - # 如果是提及时且没有可用动作，直接返回空列表，不调用LLM以节省token - if is_mentioned and not filtered_actions: - logger.info(f"{self.log_prefix}提及时没有可用动作，跳过plan调用") - return [] - # 构建包含所有动作的提示词 prompt, message_id_list = await self.build_planner_prompt( is_group_chat=is_group_chat, @@ -333,8 +352,6 @@ class ActionPlanner: current_available_actions=filtered_actions, chat_content_block=chat_content_block, message_id_list=message_id_list, - interest=global_config.personality.interest, - is_mentioned=is_mentioned, ) # 调用LLM获取决策 @@ -346,6 +363,34 @@ class ActionPlanner: loop_start_time=loop_start_time, ) + # 如果有强制回复消息，确保回复该消息 + if force_reply_message: + # 检查是否已经有回复该消息的 action + has_reply_to_force_message = False + for action in actions: + if action.action_type == "reply" and action.action_message and action.action_message.message_id == force_reply_message.message_id: + has_reply_to_force_message = True + break + + # 如果没有回复该消息，强制添加回复 action + if not has_reply_to_force_message: + # 移除所有 no_reply action（如果有） + actions = [a for a in actions if a.action_type != "no_reply"] + + # 创建强制回复 action + available_actions_dict = dict(current_available_actions) + force_reply_action = ActionPlannerInfo( + action_type="reply", + reasoning="用户提及了我，必须回复该消息", + action_data={"loop_start_time": loop_start_time}, + action_message=force_reply_message, + available_actions=available_actions_dict, + action_reasoning=None, + ) + # 将强制回复 action 放在最前面 + actions.insert(0, force_reply_action) + logger.info(f"{self.log_prefix} 检测到强制回复消息，已添加回复动作") + logger.info( f"{self.log_prefix}Planner:{reasoning}。选择了{len(actions)}个动作: {' '.join([a.action_type for a in actions])}" ) @@ -406,32 +451,6 @@ class ActionPlanner: return plan_log_str - def _has_consecutive_no_reply(self, min_count: int = 3) -> bool: - """ - 检查是否有连续min_count次以上的no_reply - - Args: - min_count: 需要连续的最少次数，默认3 - - Returns: - 如果有连续min_count次以上no_reply返回True，否则返回False - """ - consecutive_count = 0 - - # 从后往前遍历plan_log，检查最新的连续记录 - for _reasoning, _timestamp, content in reversed(self.plan_log): - if isinstance(content, list) and all(isinstance(action, ActionPlannerInfo) for action in content): - # 检查所有action是否都是no_reply - if all(action.action_type == "no_reply" for action in content): - consecutive_count += 1 - if consecutive_count >= min_count: - return True - else: - # 如果遇到非no_reply的action，重置计数 - break - - return False - async def build_planner_prompt( self, is_group_chat: bool, @@ -440,7 +459,6 @@ class ActionPlanner: message_id_list: List[Tuple[str, "DatabaseMessages"]], chat_content_block: str = "", interest: str = "", - is_mentioned: bool = False, ) -> tuple[str, List[Tuple[str, "DatabaseMessages"]]]: """构建 Planner LLM 的提示词 (获取模板并填充数据)""" try: @@ -461,48 +479,35 @@ class ActionPlanner: ) name_block = f"你的名字是{bot_name}{bot_nickname}，请注意哪些是你自己的发言。" - # 根据是否是提及时选择不同的模板 - if is_mentioned: - # 提及时使用简化版提示词，不需要reply、no_reply、no_reply_until_call - planner_prompt_template = await global_prompt_manager.get_prompt_async("planner_prompt_mentioned") - prompt = planner_prompt_template.format( - time_block=time_block, - chat_context_description=chat_context_description, - chat_content_block=chat_content_block, - actions_before_now_block=actions_before_now_block, - action_options_text=action_options_block, - moderation_prompt=moderation_prompt_block, - name_block=name_block, - interest=interest, - plan_style=global_config.personality.plan_style, + # 根据 think_mode 配置决定 reply action 的示例 JSON + # 在 JSON 中直接作为 action 参数携带 unknown_words + if global_config.chat.think_mode == "classic": + reply_action_example = ( + '{{"action":"reply", "target_message_id":"消息id(m+数字)", ' + '"unknown_words":["词语1","词语2"]}}' ) else: - # 正常流程使用完整版提示词 - # 检查是否有连续3次以上no_reply，如果有则添加no_reply_until_call选项 - no_reply_until_call_block = "" - if self._has_consecutive_no_reply(min_count=3): - no_reply_until_call_block = """no_reply_until_call -动作描述： -保持沉默，直到有人直接叫你的名字 -当前话题不感兴趣时使用，或有人不喜欢你的发言时使用 -当你频繁选择no_reply时使用，表示话题暂时与你无关 -{{"action":"no_reply_until_call"}} -""" - - planner_prompt_template = await global_prompt_manager.get_prompt_async("planner_prompt") - prompt = planner_prompt_template.format( - time_block=time_block, - chat_context_description=chat_context_description, - chat_content_block=chat_content_block, - actions_before_now_block=actions_before_now_block, - action_options_text=action_options_block, - no_reply_until_call_block=no_reply_until_call_block, - moderation_prompt=moderation_prompt_block, - name_block=name_block, - interest=interest, - plan_style=global_config.personality.plan_style, + reply_action_example = ( + "5.think_level表示思考深度，0表示该回复不需要思考和回忆，1表示该回复需要进行回忆和思考\n" + + '{{"action":"reply", "think_level":数值等级(0或1), ' + '"target_message_id":"消息id(m+数字)", ' + '"unknown_words":["词语1","词语2"]}}' ) + planner_prompt_template = await global_prompt_manager.get_prompt_async("planner_prompt") + prompt = planner_prompt_template.format( + time_block=time_block, + chat_context_description=chat_context_description, + chat_content_block=chat_content_block, + actions_before_now_block=actions_before_now_block, + action_options_text=action_options_block, + moderation_prompt=moderation_prompt_block, + name_block=name_block, + interest=interest, + plan_style=global_config.personality.plan_style, + reply_action_example=reply_action_example, + ) + return prompt, message_id_list except Exception as e: logger.error(f"构建 Planner 提示词时出错: {e}") @@ -672,6 +677,12 @@ class ActionPlanner: action.action_data = action.action_data or {} action.action_data["loop_start_time"] = loop_start_time + # 去重：如果同一个动作被选择了多次，随机选择其中一个 + if actions: + shuffled = actions.copy() + random.shuffle(shuffled) + actions = list({a.action_type: a for a in shuffled}.values()) + logger.debug(f"{self.log_prefix}规划器选择了{len(actions)}个动作: {' '.join([a.action_type for a in actions])}") return extracted_reasoning, actions @@ -723,28 +734,88 @@ class ActionPlanner: # 尝试解析每一行作为独立的JSON对象 json_obj = json.loads(repair_json(line)) if isinstance(json_obj, dict): - json_objects.append(json_obj) + # 过滤掉空字典，避免单个 { 字符被错误修复为 {} 的情况 + if json_obj: + json_objects.append(json_obj) elif isinstance(json_obj, list): for item in json_obj: - if isinstance(item, dict): + if isinstance(item, dict) and item: json_objects.append(item) except json.JSONDecodeError: # 如果单行解析失败，尝试将整个块作为一个JSON对象或数组 pass - # 如果按行解析没有成功，尝试将整个块作为一个JSON对象或数组 + # 如果按行解析没有成功（或只得到空字典），尝试将整个块作为一个JSON对象或数组 if not json_objects: json_obj = json.loads(repair_json(json_str)) if isinstance(json_obj, dict): - json_objects.append(json_obj) + # 过滤掉空字典 + if json_obj: + json_objects.append(json_obj) elif isinstance(json_obj, list): for item in json_obj: - if isinstance(item, dict): + if isinstance(item, dict) and item: json_objects.append(item) except Exception as e: logger.warning(f"解析JSON块失败: {e}, 块内容: {match[:100]}...") continue + # 如果没有找到完整的```json```块，尝试查找不完整的代码块（缺少结尾```） + if not json_objects: + json_start_pos = content.find("```json") + if json_start_pos != -1: + # 找到```json之后的内容 + json_content_start = json_start_pos + 7 # ```json的长度 + # 提取从```json之后到内容结尾的所有内容 + incomplete_json_str = content[json_content_start:].strip() + + # 提取JSON之前的内容作为推理文本 + if json_start_pos > 0: + reasoning_content = content[:json_start_pos].strip() + reasoning_content = re.sub(r"^//\s*", "", reasoning_content, flags=re.MULTILINE) + reasoning_content = reasoning_content.strip() + + if incomplete_json_str: + try: + # 清理可能的注释和格式问题 + json_str = re.sub(r"//.*?\n", "\n", incomplete_json_str) + json_str = re.sub(r"/\*.*?\*/", "", json_str, flags=re.DOTALL) + json_str = json_str.strip() + + if json_str: + # 尝试按行分割，每行可能是一个JSON对象 + lines = [line.strip() for line in json_str.split("\n") if line.strip()] + for line in lines: + try: + json_obj = json.loads(repair_json(line)) + if isinstance(json_obj, dict): + # 过滤掉空字典，避免单个 { 字符被错误修复为 {} 的情况 + if json_obj: + json_objects.append(json_obj) + elif isinstance(json_obj, list): + for item in json_obj: + if isinstance(item, dict) and item: + json_objects.append(item) + except json.JSONDecodeError: + pass + + # 如果按行解析没有成功（或只得到空字典），尝试将整个块作为一个JSON对象或数组 + if not json_objects: + try: + json_obj = json.loads(repair_json(json_str)) + if isinstance(json_obj, dict): + # 过滤掉空字典 + if json_obj: + json_objects.append(json_obj) + elif isinstance(json_obj, list): + for item in json_obj: + if isinstance(item, dict) and item: + json_objects.append(item) + except Exception as e: + logger.debug(f"尝试解析不完整的JSON代码块失败: {e}") + except Exception as e: + logger.debug(f"处理不完整的JSON代码块时出错: {e}") + return json_objects, reasoning_content diff --git a/src/chat/replyer/group_generator.py b/src/chat/replyer/group_generator.py index cc948db1..1ec04556 100644 --- a/src/chat/replyer/group_generator.py +++ b/src/chat/replyer/group_generator.py @@ -18,13 +18,12 @@ 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.express.expression_selector import expression_selector +from src.bw_learner.expression_selector import expression_selector from src.plugin_system.apis.message_api import translate_pid_to_description # from src.memory_system.memory_activator import MemoryActivator @@ -36,6 +35,7 @@ from src.chat.replyer.prompt.lpmm_prompt import init_lpmm_prompt from src.chat.replyer.prompt.replyer_prompt import init_replyer_prompt from src.chat.replyer.prompt.rewrite_prompt import init_rewrite_prompt from src.memory_system.memory_retrieval import init_memory_retrieval_prompt, build_memory_retrieval_prompt +from src.bw_learner.jargon_explainer import explain_jargon_in_context, retrieve_concepts_with_jargon init_lpmm_prompt() init_replyer_prompt() @@ -72,6 +72,8 @@ class DefaultReplyer: stream_id: Optional[str] = None, reply_message: Optional[DatabaseMessages] = None, reply_time_point: Optional[float] = time.time(), + think_level: int = 1, + unknown_words: Optional[List[str]] = None, ) -> Tuple[bool, LLMGenerationDataModel]: # sourcery skip: merge-nested-ifs """ @@ -97,8 +99,10 @@ class DefaultReplyer: available_actions = {} try: # 3. 构建 Prompt + timing_logs = [] + almost_zero_str = "" with Timer("构建Prompt", {}): # 内部计时器，可选保留 - prompt, selected_expressions = await self.build_prompt_reply_context( + prompt, selected_expressions, timing_logs, almost_zero_str = await self.build_prompt_reply_context( extra_info=extra_info, available_actions=available_actions, chosen_actions=chosen_actions, @@ -106,6 +110,8 @@ class DefaultReplyer: reply_message=reply_message, reply_reason=reply_reason, reply_time_point=reply_time_point, + think_level=think_level, + unknown_words=unknown_words, ) llm_response.prompt = prompt llm_response.selected_expressions = selected_expressions @@ -134,10 +140,22 @@ class DefaultReplyer: content, reasoning_content, model_name, tool_call = await self.llm_generate_content(prompt) # logger.debug(f"replyer生成内容: {content}") - logger.info(f"replyer生成内容: {content}") - if global_config.debug.show_replyer_reasoning: - logger.info(f"replyer生成推理:\n{reasoning_content}") - logger.info(f"replyer生成模型: {model_name}") + # 统一输出所有日志信息，使用try-except确保即使某个步骤出错也能输出 + try: + # 1. 输出回复准备日志 + timing_log_str = f"回复准备: {'; '.join(timing_logs)}; {almost_zero_str} <0.1s" if timing_logs or almost_zero_str else "回复准备: 无计时信息" + logger.info(timing_log_str) + # 2. 输出Prompt日志 + if global_config.debug.show_replyer_prompt: + logger.info(f"\n{prompt}\n") + else: + logger.debug(f"\nreplyer_Prompt:{prompt}\n") + # 3. 输出模型生成内容和推理日志 + logger.info(f"模型: [{model_name}][思考等级:{think_level}]生成内容: {content}") + if global_config.debug.show_replyer_reasoning and reasoning_content: + logger.info(f"模型: [{model_name}][思考等级:{think_level}]生成推理:\n{reasoning_content}") + except Exception as e: + logger.warning(f"输出日志时出错: {e}") llm_response.content = content llm_response.reasoning = reasoning_content @@ -161,6 +179,21 @@ class DefaultReplyer: except Exception as llm_e: # 精简报错信息 logger.error(f"LLM 生成失败: {llm_e}") + # 即使LLM生成失败，也尝试输出已收集的日志信息 + try: + # 1. 输出回复准备日志 + timing_log_str = f"回复准备: {'; '.join(timing_logs)}; {almost_zero_str} <0.1s" if timing_logs or almost_zero_str else "回复准备: 无计时信息" + logger.info(timing_log_str) + # 2. 输出Prompt日志 + if global_config.debug.show_replyer_prompt: + logger.info(f"\n{prompt}\n") + else: + logger.debug(f"\nreplyer_Prompt:{prompt}\n") + # 3. 输出模型生成失败信息 + logger.info("模型生成失败，无法输出生成内容和推理") + except Exception as log_e: + logger.warning(f"输出日志时出错: {log_e}") + return False, llm_response # LLM 调用失败则无法生成回复 return True, llm_response @@ -227,7 +260,7 @@ class DefaultReplyer: return False, llm_response async def build_expression_habits( - self, chat_history: str, target: str, reply_reason: str = "" + self, chat_history: str, target: str, reply_reason: str = "", think_level: int = 1 ) -> Tuple[str, List[int]]: # sourcery skip: for-append-to-extend """构建表达习惯块 @@ -236,6 +269,7 @@ class DefaultReplyer: chat_history: 聊天历史记录 target: 目标消息内容 reply_reason: planner给出的回复理由 + think_level: 思考级别，0/1/2 Returns: str: 表达习惯信息字符串 @@ -248,14 +282,19 @@ class DefaultReplyer: # 使用从处理器传来的选中表达方式 # 使用模型预测选择表达方式 selected_expressions, selected_ids = await expression_selector.select_suitable_expressions( - self.chat_stream.stream_id, chat_history, max_num=8, target_message=target, reply_reason=reply_reason + self.chat_stream.stream_id, + chat_history, + max_num=8, + target_message=target, + reply_reason=reply_reason, + think_level=think_level, ) 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']}") + style_habits.append(f"当{expr['situation']}时：{expr['style']}") else: logger.debug("没有从处理器获得表达方式，将使用空的表达方式") # 不再在replyer中进行随机选择，全部交给处理器处理 @@ -271,13 +310,6 @@ class DefaultReplyer: 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_tool_info(self, chat_history: str, sender: str, target: str, enable_tool: bool = True) -> str: """构建工具信息块 @@ -458,6 +490,57 @@ class DefaultReplyer: duration = end_time - start_time return name, result, duration + async def _build_disabled_jargon_explanation(self) -> str: + """当关闭黑话解释时使用的占位协程，避免额外的LLM调用""" + return "" + + async def _build_unknown_words_jargon(self, unknown_words: Optional[List[str]], chat_id: str) -> str: + """针对 Planner 提供的未知词语列表执行黑话检索""" + if not unknown_words: + return "" + # 清洗未知词语列表，只保留非空字符串 + concepts: List[str] = [] + for item in unknown_words: + if isinstance(item, str): + s = item.strip() + if s: + concepts.append(s) + if not concepts: + return "" + try: + return await retrieve_concepts_with_jargon(concepts, chat_id) + except Exception as e: + logger.error(f"未知词语黑话检索失败: {e}") + return "" + + async def _build_jargon_explanation( + self, + chat_id: str, + messages_short: List[DatabaseMessages], + chat_talking_prompt_short: str, + unknown_words: Optional[List[str]], + ) -> str: + """ + 统一的黑话解释构建函数： + - 根据 enable_jargon_explanation / jargon_mode 决定具体策略 + """ + enable_jargon_explanation = getattr(global_config.expression, "enable_jargon_explanation", True) + if not enable_jargon_explanation: + return "" + + jargon_mode = getattr(global_config.expression, "jargon_mode", "context") + + # planner 模式：仅使用 Planner 的 unknown_words + if jargon_mode == "planner": + return await self._build_unknown_words_jargon(unknown_words, chat_id) + + # 默认 / context 模式：使用上下文自动匹配黑话 + try: + return await explain_jargon_in_context(chat_id, messages_short, chat_talking_prompt_short) + except Exception as e: + logger.error(f"上下文黑话解释失败: {e}") + return "" + def build_chat_history_prompts( self, message_list_before_now: List[DatabaseMessages], target_user_id: str, sender: str ) -> Tuple[str, str]: @@ -605,7 +688,7 @@ class DefaultReplyer: # 获取基础personality prompt_personality = global_config.personality.personality - # 检查是否需要随机替换为状态 + # 检查是否需要随机替换为状态（personality 本体） if ( global_config.personality.states and global_config.personality.state_probability > 0 @@ -642,16 +725,10 @@ class DefaultReplyer: # 判断是否为群聊 is_group = stream_type == "group" - # 使用与 ChatStream.get_stream_id 相同的逻辑生成 chat_id - import hashlib - - if is_group: - components = [platform, str(id_str)] - else: - components = [platform, str(id_str), "private"] - key = "_".join(components) - chat_id = hashlib.md5(key.encode()).hexdigest() + # 使用 ChatManager 提供的接口生成 chat_id，避免在此重复实现逻辑 + from src.chat.message_receive.chat_stream import get_chat_manager + chat_id = get_chat_manager().get_stream_id(platform, str(id_str), is_group=is_group) return chat_id, prompt_content except (ValueError, IndexError): @@ -704,7 +781,9 @@ class DefaultReplyer: chosen_actions: Optional[List[ActionPlannerInfo]] = None, enable_tool: bool = True, reply_time_point: Optional[float] = time.time(), - ) -> Tuple[str, List[int]]: + think_level: int = 1, + unknown_words: Optional[List[str]] = None, + ) -> Tuple[str, List[int], List[str], str]: """ 构建回复器上下文 @@ -750,12 +829,14 @@ class DefaultReplyer: chat_id=chat_id, timestamp=reply_time_point, limit=global_config.chat.max_context_size * 1, + filter_intercept_message_level=1, ) message_list_before_short = get_raw_msg_before_timestamp_with_chat( chat_id=chat_id, timestamp=reply_time_point, limit=int(global_config.chat.max_context_size * 0.33), + filter_intercept_message_level=1, ) person_list_short: List[Person] = [] @@ -786,10 +867,16 @@ class DefaultReplyer: show_actions=True, ) - # 并行执行七个构建任务 + # 统一黑话解释构建：根据配置选择上下文或 Planner 模式 + jargon_coroutine = self._build_jargon_explanation( + chat_id, message_list_before_short, chat_talking_prompt_short, unknown_words + ) + + # 并行执行构建任务（包括黑话解释，可配置关闭） task_results = await asyncio.gather( self._time_and_run_task( - self.build_expression_habits(chat_talking_prompt_short, target, reply_reason), "expression_habits" + self.build_expression_habits(chat_talking_prompt_short, target, reply_reason, think_level=think_level), + "expression_habits", ), self._time_and_run_task( self.build_tool_info(chat_talking_prompt_short, sender, target, enable_tool=enable_tool), "tool_info" @@ -797,13 +884,13 @@ class DefaultReplyer: 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( build_memory_retrieval_prompt( - chat_talking_prompt_short, sender, target, self.chat_stream, self.tool_executor + chat_talking_prompt_short, sender, target, self.chat_stream, think_level=think_level ), "memory_retrieval", ), + self._time_and_run_task(jargon_coroutine, "jargon_explanation"), ) # 任务名称中英文映射 @@ -814,8 +901,8 @@ class DefaultReplyer: "prompt_info": "获取知识", "actions_info": "动作信息", "personality_prompt": "人格信息", - "mood_state_prompt": "情绪状态", "memory_retrieval": "记忆检索", + "jargon_explanation": "黑话解释", } # 处理结果 @@ -831,9 +918,8 @@ class DefaultReplyer: continue timing_logs.append(f"{chinese_name}: {duration:.1f}s") - if duration > 12: - logger.warning(f"回复生成前信息获取耗时过长: {chinese_name} 耗时: {duration:.1f}s，请使用更快的模型") - logger.info(f"回复准备: {'; '.join(timing_logs)}; {almost_zero_str} <0.1s") + # 不再在这里输出日志，而是返回给调用者统一输出 + # logger.info(f"回复准备: {'; '.join(timing_logs)}; {almost_zero_str} <0.1s") expression_habits_block, selected_expressions = results_dict["expression_habits"] expression_habits_block: str @@ -845,13 +931,8 @@ class DefaultReplyer: personality_prompt: str = results_dict["personality_prompt"] memory_retrieval: str = results_dict["memory_retrieval"] keywords_reaction_prompt = await self.build_keywords_reaction_prompt(target) - mood_state_prompt: str = results_dict["mood_state_prompt"] - - # 从 chosen_actions 中提取 planner 的整体思考理由 - planner_reasoning = "" - if global_config.chat.include_planner_reasoning and reply_reason: - # 如果没有 chosen_actions，使用 reply_reason 作为备选 - planner_reasoning = f"你的想法是：{reply_reason}" + jargon_explanation: str = results_dict.get("jargon_explanation") or "" + planner_reasoning = f"你的想法是：{reply_reason}" if extra_info: extra_info_block = f"以下是你在回复时需要参考的信息，现在请你阅读以下内容，进行决策\n{extra_info}\n以上是你在回复时需要参考的信息，现在请你阅读以下内容，进行决策" @@ -886,29 +967,47 @@ class DefaultReplyer: chat_prompt_content = self.get_chat_prompt_for_chat(chat_id) chat_prompt_block = f"{chat_prompt_content}\n" if chat_prompt_content else "" - # 固定使用群聊回复模板 + # 根据think_level选择不同的回复模板 + # think_level=0: 轻量回复（简短平淡） + # think_level=1: 中等回复（日常口语化） + if think_level == 0: + prompt_name = "replyer_prompt_0" + else: # think_level == 1 或默认 + prompt_name = "replyer_prompt" + + # 根据配置构建最终的 reply_style：支持 multiple_reply_style 按概率随机替换 + reply_style = global_config.personality.reply_style + multi_styles = getattr(global_config.personality, "multiple_reply_style", None) or [] + multi_prob = getattr(global_config.personality, "multiple_probability", 0.0) or 0.0 + if multi_styles and multi_prob > 0 and random.random() < multi_prob: + try: + reply_style = random.choice(list(multi_styles)) + except Exception: + # 兜底：即使 multiple_reply_style 配置异常也不影响正常回复 + reply_style = global_config.personality.reply_style + return await global_prompt_manager.format_prompt( - "replyer_prompt", + prompt_name, expression_habits_block=expression_habits_block, tool_info_block=tool_info, bot_name=global_config.bot.nickname, knowledge_prompt=prompt_info, - mood_state=mood_state_prompt, # relation_info_block=relation_info, extra_info_block=extra_info_block, + jargon_explanation=jargon_explanation, identity=personality_prompt, action_descriptions=actions_info, sender_name=sender, dialogue_prompt=dialogue_prompt, time_block=time_block, reply_target_block=reply_target_block, - reply_style=global_config.personality.reply_style, + reply_style=reply_style, keywords_reaction_prompt=keywords_reaction_prompt, moderation_prompt=moderation_prompt_block, memory_retrieval=memory_retrieval, chat_prompt=chat_prompt_block, planner_reasoning=planner_reasoning, - ), selected_expressions + ), selected_expressions, timing_logs, almost_zero_str async def build_prompt_rewrite_context( self, @@ -918,8 +1017,6 @@ class DefaultReplyer: ) -> str: # sourcery skip: merge-else-if-into-elif, remove-redundant-if chat_stream = self.chat_stream chat_id = chat_stream.stream_id - is_group_chat = bool(chat_stream.group_info) - sender, target = self._parse_reply_target(reply_to) target = replace_user_references(target, chat_stream.platform, replace_bot_name=True) @@ -933,6 +1030,7 @@ class DefaultReplyer: chat_id=chat_id, timestamp=time.time(), limit=min(int(global_config.chat.max_context_size * 0.33), 15), + filter_intercept_message_level=1, ) chat_talking_prompt_half = build_readable_messages( message_list_before_now_half, @@ -958,61 +1056,42 @@ class DefaultReplyer: if sender and target: # 使用预先分析的内容类型结果 - if is_group_chat: - if sender: - 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}引起了你的注意，你想要在群里发言或者回复这条消息。" + if sender: + 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 = "现在，你想要在群里发言或者回复消息。" - else: # private chat - if sender: - 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 = "现在，你想要回复。" + # 只包含文字 + reply_target_block = ( + f"现在{sender}说的:{text_part}。引起了你的注意，你想要在群里发言或者回复这条消息。" + ) + elif target: + reply_target_block = f"现在{target}引起了你的注意，你想要在群里发言或者回复这条消息。" + else: + reply_target_block = "现在，你想要在群里发言或者回复消息。" else: reply_target_block = "" - if is_group_chat: - chat_target_1 = await global_prompt_manager.get_prompt_async("chat_target_group1") - chat_target_2 = await global_prompt_manager.get_prompt_async("chat_target_group2") - else: - chat_target_name = "对方" - if self.chat_target_info: - chat_target_name = self.chat_target_info.person_name or self.chat_target_info.user_nickname or "对方" - chat_target_1 = await global_prompt_manager.format_prompt( - "chat_target_private1", sender_name=chat_target_name - ) - chat_target_2 = await global_prompt_manager.format_prompt( - "chat_target_private2", sender_name=chat_target_name - ) + chat_target_1 = await global_prompt_manager.get_prompt_async("chat_target_group1") + chat_target_2 = await global_prompt_manager.get_prompt_async("chat_target_group2") template_name = "default_expressor_prompt" + # 根据配置构建最终的 reply_style：支持 multiple_reply_style 按概率随机替换 + reply_style = global_config.personality.reply_style + multi_styles = getattr(global_config.personality, "multiple_reply_style", None) or [] + multi_prob = getattr(global_config.personality, "multiple_probability", 0.0) or 0.0 + if multi_styles and multi_prob > 0 and random.random() < multi_prob: + try: + reply_style = random.choice(list(multi_styles)) + except Exception: + reply_style = global_config.personality.reply_style + return await global_prompt_manager.format_prompt( template_name, expression_habits_block=expression_habits_block, @@ -1025,7 +1104,7 @@ class DefaultReplyer: reply_target_block=reply_target_block, raw_reply=raw_reply, reason=reason, - reply_style=global_config.personality.reply_style, + reply_style=reply_style, keywords_reaction_prompt=keywords_reaction_prompt, moderation_prompt=moderation_prompt_block, ) @@ -1069,10 +1148,11 @@ class DefaultReplyer: # 直接使用已初始化的模型实例 # logger.info(f"\n{prompt}\n") - if global_config.debug.show_replyer_prompt: - logger.info(f"\n{prompt}\n") - else: - logger.debug(f"\nreplyer_Prompt:{prompt}\n") + # 不再在这里输出日志，而是返回给调用者统一输出 + # if global_config.debug.show_replyer_prompt: + # logger.info(f"\n{prompt}\n") + # else: + # logger.debug(f"\nreplyer_Prompt:{prompt}\n") content, (reasoning_content, model_name, tool_calls) = await self.express_model.generate_response_async( prompt @@ -1081,7 +1161,7 @@ class DefaultReplyer: # 移除 content 前后的换行符和空格 content = content.strip() - logger.info(f"使用 {model_name} 生成回复内容: {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/private_generator.py b/src/chat/replyer/private_generator.py index 74b04f6e..5e107b41 100644 --- a/src/chat/replyer/private_generator.py +++ b/src/chat/replyer/private_generator.py @@ -23,9 +23,8 @@ from src.chat.utils.chat_message_builder import ( get_raw_msg_before_timestamp_with_chat, replace_user_references, ) -from src.express.expression_selector import expression_selector +from src.bw_learner.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 @@ -34,12 +33,13 @@ from src.plugin_system.base.component_types import ActionInfo, EventType from src.plugin_system.apis import llm_api from src.chat.replyer.prompt.lpmm_prompt import init_lpmm_prompt -from src.chat.replyer.prompt.replyer_prompt import init_replyer_prompt +from src.chat.replyer.prompt.replyer_private_prompt import init_replyer_private_prompt from src.chat.replyer.prompt.rewrite_prompt import init_rewrite_prompt from src.memory_system.memory_retrieval import init_memory_retrieval_prompt, build_memory_retrieval_prompt +from src.bw_learner.jargon_explainer import explain_jargon_in_context init_lpmm_prompt() -init_replyer_prompt() +init_replyer_private_prompt() init_rewrite_prompt() init_memory_retrieval_prompt() @@ -71,9 +71,11 @@ class PrivateReplyer: chosen_actions: Optional[List[ActionPlannerInfo]] = None, enable_tool: bool = True, from_plugin: bool = True, + think_level: int = 1, stream_id: Optional[str] = None, reply_message: Optional[DatabaseMessages] = None, reply_time_point: Optional[float] = time.time(), + unknown_words: Optional[List[str]] = None, ) -> Tuple[bool, LLMGenerationDataModel]: # sourcery skip: merge-nested-ifs """ @@ -270,7 +272,7 @@ class PrivateReplyer: 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']}") + style_habits.append(f"当{expr['situation']}时：{expr['style']}") else: logger.debug("没有从处理器获得表达方式，将使用空的表达方式") # 不再在replyer中进行随机选择，全部交给处理器处理 @@ -286,13 +288,6 @@ class PrivateReplyer: 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_tool_info(self, chat_history: str, sender: str, target: str, enable_tool: bool = True) -> str: """构建工具信息块 @@ -473,6 +468,10 @@ class PrivateReplyer: duration = end_time - start_time return name, result, duration + async def _build_disabled_jargon_explanation(self) -> str: + """当关闭黑话解释时使用的占位协程，避免额外的LLM调用""" + return "" + async def build_actions_prompt( self, available_actions: Dict[str, ActionInfo], chosen_actions_info: Optional[List[ActionPlannerInfo]] = None ) -> str: @@ -556,16 +555,10 @@ class PrivateReplyer: # 判断是否为群聊 is_group = stream_type == "group" - # 使用与 ChatStream.get_stream_id 相同的逻辑生成 chat_id - import hashlib - - if is_group: - components = [platform, str(id_str)] - else: - components = [platform, str(id_str), "private"] - key = "_".join(components) - chat_id = hashlib.md5(key.encode()).hexdigest() + # 使用 ChatManager 提供的接口生成 chat_id，避免在此重复实现逻辑 + from src.chat.message_receive.chat_stream import get_chat_manager + chat_id = get_chat_manager().get_stream_id(platform, str(id_str), is_group=is_group) return chat_id, prompt_content except (ValueError, IndexError): @@ -662,6 +655,7 @@ class PrivateReplyer: chat_id=chat_id, timestamp=time.time(), limit=global_config.chat.max_context_size, + filter_intercept_message_level=1, ) dialogue_prompt = build_readable_messages( @@ -676,6 +670,7 @@ class PrivateReplyer: chat_id=chat_id, timestamp=time.time(), limit=int(global_config.chat.max_context_size * 0.33), + filter_intercept_message_level=1, ) person_list_short: List[Person] = [] @@ -706,7 +701,14 @@ class PrivateReplyer: show_actions=True, ) - # 并行执行八个构建任务 + # 根据配置决定是否启用黑话解释 + enable_jargon_explanation = getattr(global_config.expression, "enable_jargon_explanation", True) + if enable_jargon_explanation: + jargon_coroutine = explain_jargon_in_context(chat_id, message_list_before_short, chat_talking_prompt_short) + else: + jargon_coroutine = self._build_disabled_jargon_explanation() + + # 并行执行九个构建任务（包括黑话解释，可配置关闭） task_results = await asyncio.gather( self._time_and_run_task( self.build_expression_habits(chat_talking_prompt_short, target, reply_reason), "expression_habits" @@ -718,13 +720,13 @@ 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"), self._time_and_run_task( build_memory_retrieval_prompt( chat_talking_prompt_short, sender, target, self.chat_stream, self.tool_executor ), "memory_retrieval", ), + self._time_and_run_task(jargon_coroutine, "jargon_explanation"), ) # 任务名称中英文映射 @@ -735,8 +737,8 @@ class PrivateReplyer: "prompt_info": "获取知识", "actions_info": "动作信息", "personality_prompt": "人格信息", - "mood_state_prompt": "情绪状态", "memory_retrieval": "记忆检索", + "jargon_explanation": "黑话解释", } # 处理结果 @@ -752,8 +754,6 @@ class PrivateReplyer: continue timing_logs.append(f"{chinese_name}: {duration:.1f}s") - if duration > 12: - logger.warning(f"回复生成前信息获取耗时过长: {chinese_name} 耗时: {duration:.1f}s，请使用更快的模型") logger.info(f"回复准备: {'; '.join(timing_logs)}; {almost_zero_str} <0.1s") expression_habits_block, selected_expressions = results_dict["expression_habits"] @@ -764,15 +764,10 @@ class PrivateReplyer: 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"] memory_retrieval: str = results_dict["memory_retrieval"] keywords_reaction_prompt = await self.build_keywords_reaction_prompt(target) - - # 从 chosen_actions 中提取 planner 的整体思考理由 - planner_reasoning = "" - if global_config.chat.include_planner_reasoning and reply_reason: - # 如果没有 chosen_actions，使用 reply_reason 作为备选 - planner_reasoning = f"你的想法是：{reply_reason}" + jargon_explanation: str = results_dict.get("jargon_explanation") or "" + planner_reasoning = f"你的想法是：{reply_reason}" if extra_info: extra_info_block = f"以下是你在回复时需要参考的信息，现在请你阅读以下内容，进行决策\n{extra_info}\n以上是你在回复时需要参考的信息，现在请你阅读以下内容，进行决策" @@ -807,12 +802,12 @@ class PrivateReplyer: expression_habits_block=expression_habits_block, tool_info_block=tool_info, knowledge_prompt=prompt_info, - mood_state=mood_state_prompt, relation_info_block=relation_info, extra_info_block=extra_info_block, identity=personality_prompt, action_descriptions=actions_info, dialogue_prompt=dialogue_prompt, + jargon_explanation=jargon_explanation, time_block=time_block, target=target, reason=reply_reason, @@ -829,12 +824,12 @@ class PrivateReplyer: expression_habits_block=expression_habits_block, tool_info_block=tool_info, knowledge_prompt=prompt_info, - mood_state=mood_state_prompt, relation_info_block=relation_info, extra_info_block=extra_info_block, identity=personality_prompt, action_descriptions=actions_info, dialogue_prompt=dialogue_prompt, + jargon_explanation=jargon_explanation, time_block=time_block, reply_target_block=reply_target_block, reply_style=global_config.personality.reply_style, @@ -869,6 +864,7 @@ class PrivateReplyer: chat_id=chat_id, timestamp=time.time(), limit=min(int(global_config.chat.max_context_size * 0.33), 15), + filter_intercept_message_level=1, ) chat_talking_prompt_half = build_readable_messages( message_list_before_now_half, @@ -894,59 +890,30 @@ class PrivateReplyer: ) if sender and target: - # 使用预先分析的内容类型结果 - if is_group_chat: - if sender: - 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}引起了你的注意，你想要在群里发言或者回复这条消息。" + if sender: + 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 = "现在，你想要在群里发言或者回复消息。" - else: # private chat - if sender: - 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 = "现在，你想要回复。" + # 只包含文字 + reply_target_block = f"现在{sender}说的:{text_part}。引起了你的注意，针对这条消息回复。" + elif target: + reply_target_block = f"现在{target}引起了你的注意，针对这条消息回复。" + else: + reply_target_block = "现在，你想要回复。" else: reply_target_block = "" - if is_group_chat: - chat_target_1 = await global_prompt_manager.get_prompt_async("chat_target_group1") - chat_target_2 = await global_prompt_manager.get_prompt_async("chat_target_group2") - else: - chat_target_name = "对方" - if self.chat_target_info: - chat_target_name = self.chat_target_info.person_name or self.chat_target_info.user_nickname or "对方" - chat_target_1 = await global_prompt_manager.format_prompt( - "chat_target_private1", sender_name=chat_target_name - ) - chat_target_2 = await global_prompt_manager.format_prompt( - "chat_target_private2", sender_name=chat_target_name - ) + chat_target_name = "对方" + if self.chat_target_info: + chat_target_name = self.chat_target_info.person_name or self.chat_target_info.user_nickname or "对方" + chat_target_1 = await global_prompt_manager.format_prompt("chat_target_private1", sender_name=chat_target_name) + chat_target_2 = await global_prompt_manager.format_prompt("chat_target_private2", sender_name=chat_target_name) template_name = "default_expressor_prompt" diff --git a/src/chat/replyer/prompt/replyer_private_prompt.py b/src/chat/replyer/prompt/replyer_private_prompt.py new file mode 100644 index 00000000..7dfd54e7 --- /dev/null +++ b/src/chat/replyer/prompt/replyer_private_prompt.py @@ -0,0 +1,41 @@ +from src.chat.utils.prompt_builder import Prompt + + +def init_replyer_private_prompt(): + Prompt( + """{knowledge_prompt}{tool_info_block}{extra_info_block} + {expression_habits_block}{memory_retrieval}{jargon_explanation} + + 你正在和{sender_name}聊天，这是你们之前聊的内容: + {time_block} + {dialogue_prompt} + + {reply_target_block}。 + {planner_reasoning} + {identity} + {chat_prompt}你正在和{sender_name}聊天,现在请你读读之前的聊天记录，然后给出日常且口语化的回复，平淡一些， + 尽量简短一些。{keywords_reaction_prompt}请注意把握聊天内容，不要回复的太有条理。 + {reply_style} + 请注意不要输出多余内容(包括前后缀，冒号和引号，括号，表情等)，只输出回复内容。 + {moderation_prompt}不要输出多余内容(包括前后缀，冒号和引号，括号，表情包，at或 @等 )。""", + "private_replyer_prompt", + ) + + Prompt( + """{knowledge_prompt}{tool_info_block}{extra_info_block} +{expression_habits_block}{memory_retrieval}{jargon_explanation} + +你正在和{sender_name}聊天，这是你们之前聊的内容: +{time_block} +{dialogue_prompt} + +你现在想补充说明你刚刚自己的发言内容：{target}，原因是{reason} +请你根据聊天内容，组织一条新回复。注意，{target} 是刚刚你自己的发言，你要在这基础上进一步发言，请按照你自己的角度来继续进行回复。注意保持上下文的连贯性。 +{identity} +{chat_prompt}尽量简短一些。{keywords_reaction_prompt}请注意把握聊天内容，不要回复的太有条理，可以有个性。 +{reply_style} +请注意不要输出多余内容(包括前后缀，冒号和引号，括号，表情等)，只输出回复内容。 +{moderation_prompt}不要输出多余内容(包括冒号和引号，括号，表情包，at或 @等 )。 +""", + "private_replyer_self_prompt", + ) diff --git a/src/chat/replyer/prompt/replyer_prompt.py b/src/chat/replyer/prompt/replyer_prompt.py index 7c7a91e3..6b92a3a9 100644 --- a/src/chat/replyer/prompt/replyer_prompt.py +++ b/src/chat/replyer/prompt/replyer_prompt.py @@ -3,12 +3,9 @@ from src.chat.utils.prompt_builder import Prompt def init_replyer_prompt(): - Prompt("正在群里聊天", "chat_target_group2") - Prompt("和{sender_name}聊天", "chat_target_private2") - Prompt( """{knowledge_prompt}{tool_info_block}{extra_info_block} -{expression_habits_block}{memory_retrieval} +{expression_habits_block}{memory_retrieval}{jargon_explanation} 你正在qq群里聊天，下面是群里正在聊的内容，其中包含聊天记录和聊天中的图片 其中标注 {bot_name}(你) 的发言是你自己的发言，请注意区分: @@ -18,49 +15,34 @@ def init_replyer_prompt(): {reply_target_block}。 {planner_reasoning} {identity} -{chat_prompt}你正在群里聊天,现在请你读读之前的聊天记录，然后给出日常且口语化的回复，平淡一些，{mood_state} -尽量简短一些。{keywords_reaction_prompt}请注意把握聊天内容，不要回复的太有条理，可以有个性。 +{chat_prompt}你正在群里聊天,现在请你读读之前的聊天记录，然后给出日常且口语化的回复， +尽量简短一些。{keywords_reaction_prompt} +请注意把握聊天内容，不要回复的太有条理。 {reply_style} -请注意不要输出多余内容(包括前后缀，冒号和引号，括号，表情等)，只输出一句回复内容就好。 -不要输出多余内容(包括前后缀，冒号和引号，括号，表情包，at或 @等 )。 +请注意不要输出多余内容(包括不必要的前后缀，冒号，括号，表情包，at或 @等 )，只输出发言内容就好。 +最好一次对一个话题进行回复，免得啰嗦或者回复内容太乱。 现在，你说：""", - "replyer_prompt", + "replyer_prompt_0", ) Prompt( """{knowledge_prompt}{tool_info_block}{extra_info_block} -{expression_habits_block}{memory_retrieval} +{expression_habits_block}{memory_retrieval}{jargon_explanation} -你正在和{sender_name}聊天，这是你们之前聊的内容: +你正在qq群里聊天，下面是群里正在聊的内容，其中包含聊天记录和聊天中的图片 +其中标注 {bot_name}(你) 的发言是你自己的发言，请注意区分: {time_block} {dialogue_prompt} {reply_target_block}。 {planner_reasoning} {identity} -{chat_prompt}你正在和{sender_name}聊天,现在请你读读之前的聊天记录，然后给出日常且口语化的回复，平淡一些，{mood_state} -尽量简短一些。{keywords_reaction_prompt}请注意把握聊天内容，不要回复的太有条理，可以有个性。 +{chat_prompt}你正在群里聊天,现在请你读读之前的聊天记录，把握当前的话题，然后给出日常且简短的回复。 +最好一次对一个话题进行回复，免得啰嗦或者回复内容太乱。 +{keywords_reaction_prompt} +请注意把握聊天内容。 {reply_style} -请注意不要输出多余内容(包括前后缀，冒号和引号，括号，表情等)，只输出回复内容。 -{moderation_prompt}不要输出多余内容(包括前后缀，冒号和引号，括号，表情包，at或 @等 )。""", - "private_replyer_prompt", - ) - - Prompt( - """{knowledge_prompt}{tool_info_block}{extra_info_block} -{expression_habits_block}{memory_retrieval} - -你正在和{sender_name}聊天，这是你们之前聊的内容: -{time_block} -{dialogue_prompt} - -你现在想补充说明你刚刚自己的发言内容：{target}，原因是{reason} -请你根据聊天内容，组织一条新回复。注意，{target} 是刚刚你自己的发言，你要在这基础上进一步发言，请按照你自己的角度来继续进行回复。注意保持上下文的连贯性。{mood_state} -{identity} -{chat_prompt}尽量简短一些。{keywords_reaction_prompt}请注意把握聊天内容，不要回复的太有条理，可以有个性。 -{reply_style} -请注意不要输出多余内容(包括前后缀，冒号和引号，括号，表情等)，只输出回复内容。 -{moderation_prompt}不要输出多余内容(包括冒号和引号，括号，表情包，at或 @等 )。 -""", - "private_replyer_self_prompt", +请注意不要输出多余内容(包括不必要的前后缀，冒号，括号，at或 @等 )，只输出发言内容就好。 +现在，你说：""", + "replyer_prompt", ) diff --git a/src/chat/utils/chat_history_summarizer.py b/src/chat/utils/chat_history_summarizer.py deleted file mode 100644 index 7fa55834..00000000 --- a/src/chat/utils/chat_history_summarizer.py +++ /dev/null @@ -1,493 +0,0 @@ -""" -聊天内容概括器 -用于累积、打包和压缩聊天记录 -""" - -import asyncio -import json -import time -from typing import List, Optional, Set -from dataclasses import dataclass - -from src.common.logger import get_logger -from src.common.data_models.database_data_model import DatabaseMessages -from src.config.config import global_config, model_config -from src.llm_models.utils_model import LLMRequest -from src.plugin_system.apis import message_api -from src.chat.utils.chat_message_builder import build_readable_messages -from src.person_info.person_info import Person -from src.chat.message_receive.chat_stream import get_chat_manager - -logger = get_logger("chat_history_summarizer") - - -@dataclass -class MessageBatch: - """消息批次""" - - messages: List[DatabaseMessages] - start_time: float - end_time: float - is_preparing: bool = False # 是否处于准备结束模式 - - -class ChatHistorySummarizer: - """聊天内容概括器""" - - def __init__(self, chat_id: str, check_interval: int = 60): - """ - 初始化聊天内容概括器 - - Args: - chat_id: 聊天ID - check_interval: 定期检查间隔（秒），默认60秒 - """ - self.chat_id = chat_id - self._chat_display_name = self._get_chat_display_name() - self.log_prefix = f"[{self._chat_display_name}]" - - # 记录时间点，用于计算新消息 - self.last_check_time = time.time() - - # 当前累积的消息批次 - self.current_batch: Optional[MessageBatch] = None - - # LLM请求器，用于压缩聊天内容 - self.summarizer_llm = LLMRequest( - model_set=model_config.model_task_config.utils, request_type="chat_history_summarizer" - ) - - # 后台循环相关 - self.check_interval = check_interval # 检查间隔（秒） - self._periodic_task: Optional[asyncio.Task] = None - self._running = False - - def _get_chat_display_name(self) -> str: - """获取聊天显示名称""" - try: - chat_name = get_chat_manager().get_stream_name(self.chat_id) - if chat_name: - return chat_name - # 如果获取失败，使用简化的chat_id显示 - if len(self.chat_id) > 20: - return f"{self.chat_id[:8]}..." - return self.chat_id - except Exception: - # 如果获取失败，使用简化的chat_id显示 - if len(self.chat_id) > 20: - return f"{self.chat_id[:8]}..." - return self.chat_id - - async def process(self, current_time: Optional[float] = None): - """ - 处理聊天内容概括 - - Args: - current_time: 当前时间戳，如果为None则使用time.time() - """ - if current_time is None: - current_time = time.time() - - try: - # 获取从上次检查时间到当前时间的新消息 - new_messages = message_api.get_messages_by_time_in_chat( - chat_id=self.chat_id, - start_time=self.last_check_time, - end_time=current_time, - limit=0, - limit_mode="latest", - filter_mai=False, # 不过滤bot消息，因为需要检查bot是否发言 - filter_command=False, - ) - - if not new_messages: - # 没有新消息，检查是否需要打包 - if self.current_batch and self.current_batch.messages: - await self._check_and_package(current_time) - self.last_check_time = current_time - return - - logger.debug( - f"{self.log_prefix} 开始处理聊天概括，时间窗口: {self.last_check_time:.2f} -> {current_time:.2f}" - ) - - # 有新消息，更新最后检查时间 - self.last_check_time = current_time - - # 如果有当前批次，添加新消息 - if self.current_batch: - before_count = len(self.current_batch.messages) - self.current_batch.messages.extend(new_messages) - self.current_batch.end_time = current_time - logger.info(f"{self.log_prefix} 更新聊天话题: {before_count} -> {len(self.current_batch.messages)} 条消息") - else: - # 创建新批次 - self.current_batch = MessageBatch( - messages=new_messages, - start_time=new_messages[0].time if new_messages else current_time, - end_time=current_time, - ) - logger.info(f"{self.log_prefix} 新建聊天话题: {len(new_messages)} 条消息") - - # 检查是否需要打包 - await self._check_and_package(current_time) - - except Exception as e: - logger.error(f"{self.log_prefix} 处理聊天内容概括时出错: {e}") - import traceback - - traceback.print_exc() - - async def _check_and_package(self, current_time: float): - """检查是否需要打包""" - if not self.current_batch or not self.current_batch.messages: - return - - messages = self.current_batch.messages - message_count = len(messages) - last_message_time = messages[-1].time if messages else current_time - time_since_last_message = current_time - last_message_time - - # 格式化时间差显示 - if time_since_last_message < 60: - time_str = f"{time_since_last_message:.1f}秒" - elif time_since_last_message < 3600: - time_str = f"{time_since_last_message / 60:.1f}分钟" - else: - time_str = f"{time_since_last_message / 3600:.1f}小时" - - preparing_status = "是" if self.current_batch.is_preparing else "否" - - logger.info( - f"{self.log_prefix} 批次状态检查 | 消息数: {message_count} | 距最后消息: {time_str} | 准备结束模式: {preparing_status}" - ) - - # 检查打包条件 - should_package = False - - # 条件1: 消息长度超过120，直接打包 - if message_count >= 120: - should_package = True - logger.info(f"{self.log_prefix} 触发打包条件: 消息数量达到 {message_count} 条（阈值: 120条）") - - # 条件2: 最后一条消息的时间和当前时间差>600秒，直接打包 - elif time_since_last_message > 600: - should_package = True - logger.info(f"{self.log_prefix} 触发打包条件: 距最后消息 {time_str}（阈值: 10分钟）") - - # 条件3: 消息长度超过100，进入准备结束模式 - elif message_count > 100: - if not self.current_batch.is_preparing: - self.current_batch.is_preparing = True - logger.info(f"{self.log_prefix} 消息数量 {message_count} 条超过阈值（100条），进入准备结束模式") - - # 在准备结束模式下，如果最后一条消息的时间和当前时间差>10秒，就打包 - if time_since_last_message > 10: - should_package = True - logger.info(f"{self.log_prefix} 触发打包条件: 准备结束模式下，距最后消息 {time_str}（阈值: 10秒）") - - if should_package: - await self._package_and_store() - - async def _package_and_store(self): - """打包并存储聊天记录""" - if not self.current_batch or not self.current_batch.messages: - return - - messages = self.current_batch.messages - start_time = self.current_batch.start_time - end_time = self.current_batch.end_time - - logger.info( - f"{self.log_prefix} 开始打包批次 | 消息数: {len(messages)} | 时间范围: {start_time:.2f} - {end_time:.2f}" - ) - - # 检查是否有bot发言 - # 第一条消息前推600s到最后一条消息的时间内 - check_start_time = max(start_time - 600, 0) - check_end_time = end_time - - # 使用包含边界的时间范围查询 - bot_messages = message_api.get_messages_by_time_in_chat_inclusive( - chat_id=self.chat_id, - start_time=check_start_time, - end_time=check_end_time, - limit=0, - limit_mode="latest", - filter_mai=False, - filter_command=False, - ) - - # 检查是否有bot的发言 - has_bot_message = False - bot_user_id = str(global_config.bot.qq_account) - for msg in bot_messages: - if msg.user_info.user_id == bot_user_id: - has_bot_message = True - break - - if not has_bot_message: - logger.info( - f"{self.log_prefix} 批次内无Bot发言，丢弃批次 | 检查时间范围: {check_start_time:.2f} - {check_end_time:.2f}" - ) - self.current_batch = None - return - - # 有bot发言，进行压缩和存储 - try: - # 构建对话原文 - original_text = build_readable_messages( - messages=messages, - replace_bot_name=True, - timestamp_mode="normal_no_YMD", - read_mark=0.0, - truncate=False, - show_actions=False, - ) - - # 获取参与的所有人的昵称 - participants_set: Set[str] = set() - for msg in messages: - # 使用 msg.user_platform（扁平化字段）或 msg.user_info.platform - platform = ( - getattr(msg, "user_platform", None) - or (msg.user_info.platform if msg.user_info else None) - or msg.chat_info.platform - ) - person = Person(platform=platform, user_id=msg.user_info.user_id) - person_name = person.person_name - if person_name: - participants_set.add(person_name) - participants = list(participants_set) - logger.info(f"{self.log_prefix} 批次参与者: {', '.join(participants) if participants else '未知'}") - - # 使用LLM压缩聊天内容 - success, theme, keywords, summary = await self._compress_with_llm(original_text) - - if not success: - logger.warning(f"{self.log_prefix} LLM压缩失败，不存储到数据库 | 消息数: {len(messages)}") - # 清空当前批次，避免重复处理 - self.current_batch = None - return - - logger.info( - f"{self.log_prefix} LLM压缩完成 | 主题: {theme} | 关键词数: {len(keywords)} | 概括长度: {len(summary)} 字" - ) - - # 存储到数据库 - await self._store_to_database( - start_time=start_time, - end_time=end_time, - original_text=original_text, - participants=participants, - theme=theme, - keywords=keywords, - summary=summary, - ) - - logger.info(f"{self.log_prefix} 成功打包并存储聊天记录 | 消息数: {len(messages)} | 主题: {theme}") - - # 清空当前批次 - self.current_batch = None - - except Exception as e: - logger.error(f"{self.log_prefix} 打包和存储聊天记录时出错: {e}") - import traceback - - traceback.print_exc() - # 出错时也清空批次，避免重复处理 - self.current_batch = None - - async def _compress_with_llm(self, original_text: str) -> tuple[bool, str, List[str], str]: - """ - 使用LLM压缩聊天内容 - - Returns: - tuple[bool, str, List[str], str]: (是否成功, 主题, 关键词列表, 概括) - """ - prompt = f"""请对以下聊天记录进行概括，提取以下信息： - -1. 主题：这段对话的主要内容，一个简短的标题（不超过20字） -2. 关键词：这段对话的关键词，用列表形式返回（3-10个关键词） -3. 概括：对这段话的平文本概括（50-200字） - -请以JSON格式返回，格式如下： -{{ - "theme": "主题", - "keywords": ["关键词1", "关键词2", ...], - "summary": "概括内容" -}} - -聊天记录： -{original_text} - -请直接返回JSON，不要包含其他内容。""" - - try: - response, _ = await self.summarizer_llm.generate_response_async( - prompt=prompt, - temperature=0.3, - max_tokens=500, - ) - - # 解析JSON响应 - import re - - # 移除可能的markdown代码块标记 - json_str = response.strip() - json_str = re.sub(r"^```json\s*", "", json_str, flags=re.MULTILINE) - json_str = re.sub(r"^```\s*", "", json_str, flags=re.MULTILINE) - json_str = json_str.strip() - - # 尝试找到JSON对象的开始和结束位置 - # 查找第一个 { 和最后一个匹配的 } - start_idx = json_str.find("{") - if start_idx == -1: - raise ValueError("未找到JSON对象开始标记") - - # 从后往前查找最后一个 } - end_idx = json_str.rfind("}") - if end_idx == -1 or end_idx <= start_idx: - raise ValueError("未找到JSON对象结束标记") - - # 提取JSON字符串 - json_str = json_str[start_idx : end_idx + 1] - - # 尝试解析JSON - try: - result = json.loads(json_str) - except json.JSONDecodeError: - # 如果解析失败，尝试修复字符串值中的中文引号 - # 简单方法：将字符串值中的中文引号替换为转义的英文引号 - # 使用状态机方法：遍历字符串，在字符串值内部替换中文引号 - fixed_chars = [] - in_string = False - escape_next = False - i = 0 - while i < len(json_str): - char = json_str[i] - if escape_next: - fixed_chars.append(char) - escape_next = False - elif char == "\\": - fixed_chars.append(char) - escape_next = True - elif char == '"' and not escape_next: - fixed_chars.append(char) - in_string = not in_string - elif in_string and (char == '"' or char == '"'): - # 在字符串值内部，将中文引号替换为转义的英文引号 - fixed_chars.append('\\"') - else: - fixed_chars.append(char) - i += 1 - - json_str = "".join(fixed_chars) - # 再次尝试解析 - result = json.loads(json_str) - - theme = result.get("theme", "未命名对话") - keywords = result.get("keywords", []) - summary = result.get("summary", "无概括") - - # 确保keywords是列表 - if isinstance(keywords, str): - keywords = [keywords] - - return True, theme, keywords, summary - - except Exception as e: - logger.error(f"{self.log_prefix} LLM压缩聊天内容时出错: {e}") - logger.error(f"{self.log_prefix} LLM响应: {response if 'response' in locals() else 'N/A'}") - # 返回失败标志和默认值 - return False, "未命名对话", [], "压缩失败，无法生成概括" - - async def _store_to_database( - self, - start_time: float, - end_time: float, - original_text: str, - participants: List[str], - theme: str, - keywords: List[str], - summary: str, - ): - """存储到数据库""" - try: - from src.common.database.database_model import ChatHistory - from src.plugin_system.apis import database_api - - # 准备数据 - data = { - "chat_id": self.chat_id, - "start_time": start_time, - "end_time": end_time, - "original_text": original_text, - "participants": json.dumps(participants, ensure_ascii=False), - "theme": theme, - "keywords": json.dumps(keywords, ensure_ascii=False), - "summary": summary, - "count": 0, - } - - # 使用db_save存储（使用start_time和chat_id作为唯一标识） - # 由于可能有多条记录，我们使用组合键，但peewee不支持，所以使用start_time作为唯一标识 - # 但为了避免冲突，我们使用组合键：chat_id + start_time - # 由于peewee不支持组合键，我们直接创建新记录（不提供key_field和key_value） - saved_record = await database_api.db_save( - ChatHistory, - data=data, - ) - - if saved_record: - logger.debug(f"{self.log_prefix} 成功存储聊天历史记录到数据库") - else: - logger.warning(f"{self.log_prefix} 存储聊天历史记录到数据库失败") - - except Exception as e: - logger.error(f"{self.log_prefix} 存储到数据库时出错: {e}") - import traceback - - traceback.print_exc() - raise - - async def start(self): - """启动后台定期检查循环""" - if self._running: - logger.warning(f"{self.log_prefix} 后台循环已在运行，无需重复启动") - return - - self._running = True - self._periodic_task = asyncio.create_task(self._periodic_check_loop()) - logger.info(f"{self.log_prefix} 已启动后台定期检查循环 | 检查间隔: {self.check_interval}秒") - - async def stop(self): - """停止后台定期检查循环""" - self._running = False - if self._periodic_task: - self._periodic_task.cancel() - try: - await self._periodic_task - except asyncio.CancelledError: - pass - self._periodic_task = None - logger.info(f"{self.log_prefix} 已停止后台定期检查循环") - - async def _periodic_check_loop(self): - """后台定期检查循环""" - try: - while self._running: - # 执行一次检查 - await self.process() - - # 等待指定间隔后再次检查 - await asyncio.sleep(self.check_interval) - except asyncio.CancelledError: - logger.info(f"{self.log_prefix} 后台检查循环被取消") - raise - except Exception as e: - logger.error(f"{self.log_prefix} 后台检查循环出错: {e}") - import traceback - - traceback.print_exc() - self._running = False diff --git a/src/chat/utils/chat_message_builder.py b/src/chat/utils/chat_message_builder.py index 4bd7850f..156322ae 100644 --- a/src/chat/utils/chat_message_builder.py +++ b/src/chat/utils/chat_message_builder.py @@ -120,6 +120,7 @@ def get_raw_msg_by_timestamp_with_chat( limit_mode: str = "latest", filter_bot=False, filter_command=False, + filter_intercept_message_level: Optional[int] = None, ) -> List[DatabaseMessages]: """获取在特定聊天从指定时间戳到指定时间戳的消息，按时间升序排序，返回消息列表 limit: 限制返回的消息数量，0为不限制 @@ -137,6 +138,7 @@ def get_raw_msg_by_timestamp_with_chat( limit_mode=limit_mode, filter_bot=filter_bot, filter_command=filter_command, + filter_intercept_message_level=filter_intercept_message_level, ) @@ -147,6 +149,8 @@ def get_raw_msg_by_timestamp_with_chat_inclusive( limit: int = 0, limit_mode: str = "latest", filter_bot=False, + filter_command=False, + filter_intercept_message_level: Optional[int] = None, ) -> List[DatabaseMessages]: """获取在特定聊天从指定时间戳到指定时间戳的消息（包含边界），按时间升序排序，返回消息列表 limit: 限制返回的消息数量，0为不限制 @@ -157,7 +161,13 @@ def get_raw_msg_by_timestamp_with_chat_inclusive( sort_order = [("time", 1)] if limit == 0 else None # 直接将 limit_mode 传递给 find_messages return find_messages( - message_filter=filter_query, sort=sort_order, limit=limit, limit_mode=limit_mode, filter_bot=filter_bot + message_filter=filter_query, + sort=sort_order, + limit=limit, + limit_mode=limit_mode, + filter_bot=filter_bot, + filter_command=filter_command, + filter_intercept_message_level=filter_intercept_message_level, ) @@ -292,13 +302,20 @@ def get_raw_msg_before_timestamp(timestamp: float, limit: int = 0) -> List[Datab return find_messages(message_filter=filter_query, sort=sort_order, limit=limit) -def get_raw_msg_before_timestamp_with_chat(chat_id: str, timestamp: float, limit: int = 0) -> List[DatabaseMessages]: +def get_raw_msg_before_timestamp_with_chat( + chat_id: str, timestamp: float, limit: int = 0, filter_intercept_message_level: Optional[int] = None +) -> List[DatabaseMessages]: """获取指定时间戳之前的消息，按时间升序排序，返回消息列表 limit: 限制返回的消息数量，0为不限制 """ filter_query = {"chat_id": chat_id, "time": {"$lt": timestamp}} sort_order = [("time", 1)] - return find_messages(message_filter=filter_query, sort=sort_order, limit=limit) + return find_messages( + message_filter=filter_query, + sort=sort_order, + limit=limit, + filter_intercept_message_level=filter_intercept_message_level, + ) def get_raw_msg_before_timestamp_with_users( @@ -352,6 +369,7 @@ def _build_readable_messages_internal( pic_counter: int = 1, show_pic: bool = True, message_id_list: Optional[List[Tuple[str, DatabaseMessages]]] = None, + pic_single: bool = False, ) -> Tuple[str, List[Tuple[float, str, str]], Dict[str, str], int]: # sourcery skip: use-getitem-for-re-match-groups """ @@ -378,6 +396,7 @@ def _build_readable_messages_internal( if pic_id_mapping is None: pic_id_mapping = {} current_pic_counter = pic_counter + pic_description_cache: Dict[str, str] = {} # 创建时间戳到消息ID的映射，用于在消息前添加[id]标识符 timestamp_to_id_mapping: Dict[float, str] = {} @@ -400,6 +419,17 @@ def _build_readable_messages_internal( nonlocal current_pic_counter nonlocal pic_counter pic_id = match.group(1) + if pic_single: + if pic_id not in pic_description_cache: + description = "内容正在阅读，请稍等" + try: + image = Images.get_or_none(Images.image_id == pic_id) + if image and image.description: + description = image.description + except Exception: + pass + pic_description_cache[pic_id] = description + return f"[图片：{pic_description_cache[pic_id]}]" if pic_id not in pic_id_mapping: pic_id_mapping[pic_id] = f"图片{current_pic_counter}" current_pic_counter += 1 @@ -445,6 +475,8 @@ def _build_readable_messages_internal( # 使用独立函数处理用户引用格式 if content := replace_user_references(content, platform, replace_bot_name=replace_bot_name): + if getattr(message, "is_command", False): + content = f"[is_command=True] {content}" detailed_messages_raw.append((timestamp, person_name, content, False)) if not detailed_messages_raw: @@ -603,6 +635,7 @@ async def build_readable_messages_with_list( replace_bot_name: bool = True, timestamp_mode: str = "relative", truncate: bool = False, + pic_single: bool = False, ) -> Tuple[str, List[Tuple[float, str, str]]]: """ 将消息列表转换为可读的文本格式，并返回原始(时间戳, 昵称, 内容)列表。 @@ -613,10 +646,16 @@ async def build_readable_messages_with_list( replace_bot_name, timestamp_mode, truncate, + pic_id_mapping=None, + pic_counter=1, + show_pic=True, + message_id_list=None, + pic_single=pic_single, ) - if pic_mapping_info := build_pic_mapping_info(pic_id_mapping): - formatted_string = f"{pic_mapping_info}\n\n{formatted_string}" + if not pic_single: + if pic_mapping_info := build_pic_mapping_info(pic_id_mapping): + formatted_string = f"{pic_mapping_info}\n\n{formatted_string}" return formatted_string, details_list @@ -630,6 +669,7 @@ def build_readable_messages_with_id( show_actions: bool = False, show_pic: bool = True, remove_emoji_stickers: bool = False, + pic_single: bool = False, ) -> Tuple[str, List[Tuple[str, DatabaseMessages]]]: """ 将消息列表转换为可读的文本格式，并返回原始(时间戳, 昵称, 内容)列表。 @@ -647,6 +687,7 @@ def build_readable_messages_with_id( read_mark=read_mark, message_id_list=message_id_list, remove_emoji_stickers=remove_emoji_stickers, + pic_single=pic_single, ) return formatted_string, message_id_list @@ -662,6 +703,7 @@ def build_readable_messages( show_pic: bool = True, message_id_list: Optional[List[Tuple[str, DatabaseMessages]]] = None, remove_emoji_stickers: bool = False, + pic_single: bool = False, ) -> str: # sourcery skip: extract-method """ 将消息列表转换为可读的文本格式。 @@ -769,14 +811,14 @@ def build_readable_messages( truncate, show_pic=show_pic, message_id_list=message_id_list, + pic_single=pic_single, ) - # 生成图片映射信息并添加到最前面 - pic_mapping_info = build_pic_mapping_info(pic_id_mapping) - if pic_mapping_info: - return f"{pic_mapping_info}\n\n{formatted_string}" - else: - return formatted_string + if not pic_single: + pic_mapping_info = build_pic_mapping_info(pic_id_mapping) + if pic_mapping_info: + return f"{pic_mapping_info}\n\n{formatted_string}" + return formatted_string else: # 按 read_mark 分割消息 messages_before_mark = [msg for msg in copy_messages if (msg.time or 0) <= read_mark] @@ -796,6 +838,7 @@ def build_readable_messages( pic_counter, show_pic=show_pic, message_id_list=message_id_list, + pic_single=pic_single, ) formatted_after, _, pic_id_mapping, _ = _build_readable_messages_internal( messages_after_mark, @@ -806,15 +849,19 @@ def build_readable_messages( pic_counter, show_pic=show_pic, message_id_list=message_id_list, + pic_single=pic_single, ) read_mark_line = "\n--- 以上消息是你已经看过，请关注以下未读的新消息---\n" # 生成图片映射信息 - if pic_id_mapping: - pic_mapping_info = f"图片信息：\n{build_pic_mapping_info(pic_id_mapping)}\n聊天记录信息：\n" + if not pic_single: + if pic_id_mapping: + pic_mapping_info = f"图片信息：\n{build_pic_mapping_info(pic_id_mapping)}\n聊天记录信息：\n" + else: + pic_mapping_info = "聊天记录信息：\n" else: - pic_mapping_info = "聊天记录信息：\n" + pic_mapping_info = "" # 组合结果 result_parts = [] @@ -832,7 +879,7 @@ def build_readable_messages( return "".join(result_parts) -async def build_anonymous_messages(messages: List[DatabaseMessages]) -> str: +async def build_anonymous_messages(messages: List[DatabaseMessages], show_ids: bool = False) -> str: """ 构建匿名可读消息，将不同人的名称转为唯一占位符（A、B、C...），bot自己用SELF。 处理 回复 和 @ 字段，将bbb映射为匿名占位符。 @@ -889,7 +936,7 @@ async def build_anonymous_messages(messages: List[DatabaseMessages]) -> str: current_char += 1 return person_map[person_id] - for msg in messages: + for i, msg in enumerate(messages): try: platform = msg.chat_info.platform user_id = msg.user_info.user_id @@ -910,7 +957,12 @@ async def build_anonymous_messages(messages: List[DatabaseMessages]) -> str: content = replace_user_references(content, platform, anon_name_resolver, replace_bot_name=False) - header = f"{anon_name}说 " + # 构建消息头，如果启用show_ids则添加序号 + if show_ids: + header = f"[{i + 1}] {anon_name}说 " + else: + header = f"{anon_name}说 " + output_lines.append(header) stripped_line = content.strip() if stripped_line: diff --git a/src/chat/utils/statistic.py b/src/chat/utils/statistic.py index 9b5497e9..20c0843b 100644 --- a/src/chat/utils/statistic.py +++ b/src/chat/utils/statistic.py @@ -8,7 +8,7 @@ from typing import Any, Dict, Tuple, List from src.common.logger import get_logger from src.common.database.database import db -from src.common.database.database_model import OnlineTime, LLMUsage, Messages +from src.common.database.database_model import OnlineTime, LLMUsage, Messages, ActionRecords from src.manager.async_task_manager import AsyncTask from src.manager.local_store_manager import local_storage from src.config.config import global_config @@ -227,6 +227,8 @@ class StatisticOutputTask(AsyncTask): "", self._format_model_classified_stat(stats["last_hour"]), "", + self._format_module_classified_stat(stats["last_hour"]), + "", self._format_chat_stat(stats["last_hour"]), self.SEP_LINE, "", @@ -503,13 +505,6 @@ class StatisticOutputTask(AsyncTask): for period_key, _ in collect_period } - # 获取bot的QQ账号 - bot_qq_account = ( - str(global_config.bot.qq_account) - if hasattr(global_config, "bot") and hasattr(global_config.bot, "qq_account") - else "" - ) - query_start_timestamp = collect_period[-1][1].timestamp() # Messages.time is a DoubleField (timestamp) for message in Messages.select().where(Messages.time >= query_start_timestamp): # type: ignore message_time_ts = message.time # This is a float timestamp @@ -535,7 +530,7 @@ class StatisticOutputTask(AsyncTask): if not chat_id: # Should not happen if above logic is correct continue - # Update name_mapping + # Update name_mapping（仅用于展示聊天名称） try: if chat_id in self.name_mapping: if chat_name != self.name_mapping[chat_id][0] and message_time_ts > self.name_mapping[chat_id][1]: @@ -547,19 +542,30 @@ class StatisticOutputTask(AsyncTask): # 重置为正确的格式 self.name_mapping[chat_id] = (chat_name, message_time_ts) - # 检查是否是bot发送的消息（回复） - is_bot_reply = False - if bot_qq_account and message.user_id == bot_qq_account: - is_bot_reply = True - for idx, (_, period_start_dt) in enumerate(collect_period): if message_time_ts >= period_start_dt.timestamp(): for period_key, _ in collect_period[idx:]: stats[period_key][TOTAL_MSG_CNT] += 1 stats[period_key][MSG_CNT_BY_CHAT][chat_id] += 1 - if is_bot_reply: - stats[period_key][TOTAL_REPLY_CNT] += 1 break + + # 使用 ActionRecords 中的 reply 动作次数作为回复数基准 + try: + action_query_start_timestamp = collect_period[-1][1].timestamp() + for action in ActionRecords.select().where(ActionRecords.time >= action_query_start_timestamp): # type: ignore + # 仅统计已完成的 reply 动作 + if action.action_name != "reply" or not action.action_done: + continue + + action_time_ts = action.time + for idx, (_, period_start_dt) in enumerate(collect_period): + if action_time_ts >= period_start_dt.timestamp(): + for period_key, _ in collect_period[idx:]: + stats[period_key][TOTAL_REPLY_CNT] += 1 + break + except Exception as e: + logger.warning(f"统计 reply 动作次数失败，将回复数视为 0，错误信息：{e}") + return stats def _collect_all_statistics(self, now: datetime) -> Dict[str, Dict[str, Any]]: @@ -737,11 +743,13 @@ class StatisticOutputTask(AsyncTask): """ if stats[TOTAL_REQ_CNT] <= 0: return "" - data_fmt = "{:<32} {:>10} {:>12} {:>12} {:>12} {:>9.2f}¥ {:>10.1f} {:>10.1f}" + data_fmt = "{:<32} {:>10} {:>12} {:>12} {:>12} {:>9.2f}¥ {:>10.1f} {:>10.1f} {:>12} {:>12}" + + total_replies = stats.get(TOTAL_REPLY_CNT, 0) output = [ "按模型分类统计:", - " 模型名称 调用次数 输入Token 输出Token Token总量 累计花费 平均耗时(秒) 标准差(秒)", + " 模型名称 调用次数 输入Token 输出Token Token总量 累计花费 平均耗时(秒) 标准差(秒) 每次回复平均调用次数 每次回复平均Token数", ] for model_name, count in sorted(stats[REQ_CNT_BY_MODEL].items()): name = f"{model_name[:29]}..." if len(model_name) > 32 else model_name @@ -751,11 +759,19 @@ class StatisticOutputTask(AsyncTask): cost = stats[COST_BY_MODEL][model_name] avg_time_cost = stats[AVG_TIME_COST_BY_MODEL][model_name] std_time_cost = stats[STD_TIME_COST_BY_MODEL][model_name] + + # 计算每次回复平均值 + avg_count_per_reply = count / total_replies if total_replies > 0 else 0.0 + avg_tokens_per_reply = tokens / total_replies if total_replies > 0 else 0.0 + # 格式化大数字 formatted_count = _format_large_number(count) formatted_in_tokens = _format_large_number(in_tokens) formatted_out_tokens = _format_large_number(out_tokens) formatted_tokens = _format_large_number(tokens) + formatted_avg_count = _format_large_number(avg_count_per_reply) if total_replies > 0 else "N/A" + formatted_avg_tokens = _format_large_number(avg_tokens_per_reply) if total_replies > 0 else "N/A" + output.append( data_fmt.format( name, @@ -766,6 +782,62 @@ class StatisticOutputTask(AsyncTask): cost, avg_time_cost, std_time_cost, + formatted_avg_count, + formatted_avg_tokens, + ) + ) + + output.append("") + return "\n".join(output) + + @staticmethod + def _format_module_classified_stat(stats: Dict[str, Any]) -> str: + """ + 格式化按模块分类的统计数据 + """ + if stats[TOTAL_REQ_CNT] <= 0: + return "" + data_fmt = "{:<32} {:>10} {:>12} {:>12} {:>12} {:>9.2f}¥ {:>10.1f} {:>10.1f} {:>12} {:>12}" + + total_replies = stats.get(TOTAL_REPLY_CNT, 0) + + output = [ + "按模块分类统计:", + " 模块名称 调用次数 输入Token 输出Token Token总量 累计花费 平均耗时(秒) 标准差(秒) 每次回复平均调用次数 每次回复平均Token数", + ] + for module_name, count in sorted(stats[REQ_CNT_BY_MODULE].items()): + name = f"{module_name[:29]}..." if len(module_name) > 32 else module_name + in_tokens = stats[IN_TOK_BY_MODULE][module_name] + out_tokens = stats[OUT_TOK_BY_MODULE][module_name] + tokens = stats[TOTAL_TOK_BY_MODULE][module_name] + cost = stats[COST_BY_MODULE][module_name] + avg_time_cost = stats[AVG_TIME_COST_BY_MODULE][module_name] + std_time_cost = stats[STD_TIME_COST_BY_MODULE][module_name] + + # 计算每次回复平均值 + avg_count_per_reply = count / total_replies if total_replies > 0 else 0.0 + avg_tokens_per_reply = tokens / total_replies if total_replies > 0 else 0.0 + + # 格式化大数字 + formatted_count = _format_large_number(count) + formatted_in_tokens = _format_large_number(in_tokens) + formatted_out_tokens = _format_large_number(out_tokens) + formatted_tokens = _format_large_number(tokens) + formatted_avg_count = _format_large_number(avg_count_per_reply) if total_replies > 0 else "N/A" + formatted_avg_tokens = _format_large_number(avg_tokens_per_reply) if total_replies > 0 else "N/A" + + output.append( + data_fmt.format( + name, + formatted_count, + formatted_in_tokens, + formatted_out_tokens, + formatted_tokens, + cost, + avg_time_cost, + std_time_cost, + formatted_avg_count, + formatted_avg_tokens, ) ) @@ -849,6 +921,7 @@ class StatisticOutputTask(AsyncTask): # format总在线时间 # 按模型分类统计 + total_replies = stat_data.get(TOTAL_REPLY_CNT, 0) model_rows = "\n".join( [ f"" @@ -860,11 +933,13 @@ class StatisticOutputTask(AsyncTask): f"{stat_data[COST_BY_MODEL][model_name]:.2f} ¥" f"{stat_data[AVG_TIME_COST_BY_MODEL][model_name]:.1f} 秒" f"{stat_data[STD_TIME_COST_BY_MODEL][model_name]:.1f} 秒" + f"{_format_large_number(count / total_replies, html=True) if total_replies > 0 else 'N/A'}" + f"{_format_large_number(stat_data[TOTAL_TOK_BY_MODEL][model_name] / total_replies, html=True) if total_replies > 0 else 'N/A'}" f"" for model_name, count in sorted(stat_data[REQ_CNT_BY_MODEL].items()) ] if stat_data[REQ_CNT_BY_MODEL] - else ["暂无数据"] + else ["暂无数据"] ) # 按请求类型分类统计 type_rows = "\n".join( @@ -878,11 +953,13 @@ class StatisticOutputTask(AsyncTask): f"{stat_data[COST_BY_TYPE][req_type]:.2f} ¥" f"{stat_data[AVG_TIME_COST_BY_TYPE][req_type]:.1f} 秒" f"{stat_data[STD_TIME_COST_BY_TYPE][req_type]:.1f} 秒" + f"{_format_large_number(count / total_replies, html=True) if total_replies > 0 else 'N/A'}" + f"{_format_large_number(stat_data[TOTAL_TOK_BY_TYPE][req_type] / total_replies, html=True) if total_replies > 0 else 'N/A'}" f"" for req_type, count in sorted(stat_data[REQ_CNT_BY_TYPE].items()) ] if stat_data[REQ_CNT_BY_TYPE] - else ["暂无数据"] + else ["暂无数据"] ) # 按模块分类统计 module_rows = "\n".join( @@ -896,11 +973,13 @@ class StatisticOutputTask(AsyncTask): f"{stat_data[COST_BY_MODULE][module_name]:.2f} ¥" f"{stat_data[AVG_TIME_COST_BY_MODULE][module_name]:.1f} 秒" f"{stat_data[STD_TIME_COST_BY_MODULE][module_name]:.1f} 秒" + f"{_format_large_number(count / total_replies, html=True) if total_replies > 0 else 'N/A'}" + f"{_format_large_number(stat_data[TOTAL_TOK_BY_MODULE][module_name] / total_replies, html=True) if total_replies > 0 else 'N/A'}" f"" for module_name, count in sorted(stat_data[REQ_CNT_BY_MODULE].items()) ] if stat_data[REQ_CNT_BY_MODULE] - else ["暂无数据"] + else ["暂无数据"] ) # 聊天消息统计 @@ -975,7 +1054,7 @@ class StatisticOutputTask(AsyncTask):

按模型分类统计

- + {model_rows} @@ -986,7 +1065,7 @@ class StatisticOutputTask(AsyncTask):
模型名称调用次数输入Token输出TokenToken总量累计花费平均耗时(秒)标准差(秒)
模型名称调用次数输入Token输出TokenToken总量累计花费平均耗时(秒)标准差(秒)每次回复平均调用次数每次回复平均Token数
- + {module_rows} @@ -998,7 +1077,7 @@ class StatisticOutputTask(AsyncTask):
模块名称调用次数输入Token输出TokenToken总量累计花费平均耗时(秒)标准差(秒)
模块名称调用次数输入Token输出TokenToken总量累计花费平均耗时(秒)标准差(秒)每次回复平均调用次数每次回复平均Token数
- + {type_rows} diff --git a/src/chat/utils/utils.py b/src/chat/utils/utils.py index 0464b734..b525f03d 100644 --- a/src/chat/utils/utils.py +++ b/src/chat/utils/utils.py @@ -4,6 +4,8 @@ import time import jieba import json import ast +import os +from datetime import datetime from typing import Optional, Tuple, List, TYPE_CHECKING @@ -196,21 +198,54 @@ def split_into_sentences_w_remove_punctuation(text: str) -> list[str]: List[str]: 分割和合并后的句子列表 """ # 预处理：处理多余的换行符 - # 1. 将连续的换行符替换为单个换行符 + # 1. 将连续的换行符替换为单个换行符（保留换行符用于分割） text = re.sub(r"\n\s*\n+", "\n", text) - # 2. 处理换行符和其他分隔符的组合 - text = re.sub(r"\n\s*([，,。;\s])", r"\1", text) - text = re.sub(r"([，,。;\s])\s*\n", r"\1", text) + # 2. 处理换行符和其他分隔符的组合（保留换行符，删除其他分隔符） + text = re.sub(r"\n\s*([，,。;\s])", r"\n\1", text) + text = re.sub(r"([，,。;\s])\s*\n", r"\1\n", text) - # 处理两个汉字中间的换行符 - text = re.sub(r"([\u4e00-\u9fff])\n([\u4e00-\u9fff])", r"\1。\2", text) + # 处理两个汉字中间的换行符（保留换行符，不替换为句号，让换行符强制分割） + # text = re.sub(r"([\u4e00-\u9fff])\n([\u4e00-\u9fff])", r"\1。\2", text) # 注释掉，保留换行符用于分割 len_text = len(text) if len_text < 3: return list(text) if random.random() < 0.01 else [text] - # 定义分隔符 - separators = {"，", ",", " ", "。", ";"} + # 先标记哪些位置位于成对引号内部，避免在引号内部进行句子分割 + # 支持的引号包括：中英文单/双引号和常见中文书名号/引号 + quote_chars = { + '"', + "'", + "“", + "”", + "‘", + "’", + "「", + "」", + "『", + "』", + } + inside_quote = [False] * len_text + in_quote = False + current_quote_char = "" + for idx, ch in enumerate(text): + if ch in quote_chars: + # 遇到引号时切换状态（英文引号本身开闭相同，用同一个字符表示） + if not in_quote: + in_quote = True + current_quote_char = ch + inside_quote[idx] = False + else: + # 只有遇到同一类引号才视为关闭 + if ch == current_quote_char or ch in {'"', "'"} and current_quote_char in {'"', "'"}: + in_quote = False + current_quote_char = "" + inside_quote[idx] = False + else: + inside_quote[idx] = in_quote + + # 定义分隔符（包含换行符） + separators = {"，", ",", " ", "。", ";", "\n"} segments = [] current_segment = "" @@ -219,24 +254,42 @@ def split_into_sentences_w_remove_punctuation(text: str) -> list[str]: while i < len(text): char = text[i] if char in separators: - # 检查分割条件：如果空格左右都是英文字母、数字，或数字和英文之间，则不分割（仅对空格应用此规则） - can_split = True - if 0 < i < len(text) - 1: - prev_char = text[i - 1] - next_char = text[i + 1] - # 只对空格应用"不分割数字和数字、数字和英文、英文和数字、英文和英文之间的空格"规则 - if char == " ": - prev_is_alnum = prev_char.isdigit() or is_english_letter(prev_char) - next_is_alnum = next_char.isdigit() or is_english_letter(next_char) - if prev_is_alnum and next_is_alnum: - can_split = False + # 引号内部一律不作为分割点（包括换行） + if inside_quote[i]: + can_split = False + else: + # 换行符在不在引号内时都强制分割 + if char == "\n": + can_split = True + else: + # 检查分割条件 + can_split = True + # 检查分隔符左右是否有冒号（中英文），如果有则不分割 + if i > 0: + prev_char = text[i - 1] + if prev_char in {":", "："}: + can_split = False + if i < len(text) - 1: + next_char = text[i + 1] + if next_char in {":", "："}: + can_split = False + + # 如果左右没有冒号，再检查空格的特殊情况 + if can_split and char == " " and i > 0 and i < len(text) - 1: + prev_char = text[i - 1] + next_char = text[i + 1] + # 不分割数字和数字、数字和英文、英文和数字、英文和英文之间的空格 + prev_is_alnum = prev_char.isdigit() or is_english_letter(prev_char) + next_is_alnum = next_char.isdigit() or is_english_letter(next_char) + if prev_is_alnum and next_is_alnum: + can_split = False if can_split: # 只有当当前段不为空时才添加 if current_segment: segments.append((current_segment, char)) - # 如果当前段为空，但分隔符是空格，则也添加一个空段（保留空格） - elif char == " ": + # 如果当前段为空，但分隔符是空格或换行符，则也添加一个空段（保留分隔符） + elif char in {" ", "\n"}: segments.append(("", char)) current_segment = "" else: @@ -641,6 +694,42 @@ def get_chat_type_and_target_info(chat_id: str) -> Tuple[bool, Optional["TargetP return is_group_chat, chat_target_info +def record_replyer_action_temp(chat_id: str, reason: str, think_level: int) -> None: + """ + 临时记录replyer动作被选择的信息（仅群聊） + + Args: + chat_id: 聊天ID + reason: 选择理由 + think_level: 思考深度等级 + """ + try: + # 确保data/temp目录存在 + temp_dir = "data/temp" + os.makedirs(temp_dir, exist_ok=True) + + # 创建记录数据 + record_data = { + "chat_id": chat_id, + "reason": reason, + "think_level": think_level, + "timestamp": datetime.now().isoformat(), + } + + # 生成文件名（使用时间戳避免冲突） + timestamp_str = datetime.now().strftime("%Y%m%d_%H%M%S_%f") + filename = f"replyer_action_{timestamp_str}.json" + filepath = os.path.join(temp_dir, filename) + + # 写入文件 + with open(filepath, "w", encoding="utf-8") as f: + json.dump(record_data, f, ensure_ascii=False, indent=2) + + logger.debug(f"已记录replyer动作选择: chat_id={chat_id}, think_level={think_level}") + except Exception as e: + logger.warning(f"记录replyer动作选择失败: {e}") + + def assign_message_ids(messages: List[DatabaseMessages]) -> List[Tuple[str, DatabaseMessages]]: """ 为消息列表中的每个消息分配唯一的简短随机ID diff --git a/src/chat/utils/utils_image.py b/src/chat/utils/utils_image.py index f6012f09..1145cc83 100644 --- a/src/chat/utils/utils_image.py +++ b/src/chat/utils/utils_image.py @@ -12,7 +12,7 @@ from rich.traceback import install from src.common.logger import get_logger from src.common.database.database import db -from src.common.database.database_model import Images, ImageDescriptions +from src.common.database.database_model import Images, ImageDescriptions, EmojiDescriptionCache from src.config.config import global_config, model_config from src.llm_models.utils_model import LLMRequest @@ -40,7 +40,7 @@ class ImageManager: try: db.connect(reuse_if_open=True) - db.create_tables([Images, ImageDescriptions], safe=True) + db.create_tables([Images, ImageDescriptions, EmojiDescriptionCache], safe=True) except Exception as e: logger.error(f"数据库连接或表创建失败: {e}") @@ -49,6 +49,11 @@ class ImageManager: except Exception as e: logger.warning(f"数据库清理失败: {e}") + try: + self._cleanup_emoji_from_image_descriptions() + except Exception as e: + logger.warning(f"清理ImageDescriptions中的emoji记录失败: {e}") + self._initialized = True def _ensure_image_dir(self): @@ -119,6 +124,29 @@ class ImageManager: else: logger.info("[清理完成] 未发现无效描述记录") + @staticmethod + def _cleanup_emoji_from_image_descriptions(): + """清理Images和ImageDescriptions表中type为emoji的记录（已迁移到EmojiDescriptionCache）""" + try: + # 清理Images表中type为emoji的记录 + deleted_images = Images.delete().where(Images.type == "emoji").execute() + + # 清理ImageDescriptions表中type为emoji的记录 + deleted_descriptions = ImageDescriptions.delete().where(ImageDescriptions.type == "emoji").execute() + + total_deleted = deleted_images + deleted_descriptions + if total_deleted > 0: + logger.info( + f"[清理完成] 从Images表中删除 {deleted_images} 条emoji类型记录, " + f"从ImageDescriptions表中删除 {deleted_descriptions} 条emoji类型记录, " + f"共删除 {total_deleted} 条记录" + ) + else: + logger.info("[清理完成] Images和ImageDescriptions表中未发现emoji类型记录") + except Exception as e: + logger.error(f"清理Images和ImageDescriptions中的emoji记录时出错: {str(e)}") + raise + async def get_emoji_tag(self, image_base64: str) -> str: from src.chat.emoji_system.emoji_manager import get_emoji_manager @@ -134,8 +162,49 @@ class ImageManager: tag_str = ",".join(emotion_list) return f"[表情包：{tag_str}]" + async def _save_emoji_file_if_needed(self, image_base64: str, image_hash: str, image_format: str) -> None: + """如果启用了steal_emoji且表情包未注册，保存文件到data/emoji目录 + + Args: + image_base64: 图片的base64编码 + image_hash: 图片的MD5哈希值 + image_format: 图片格式 + """ + if not global_config.emoji.steal_emoji: + return + + try: + from src.chat.emoji_system.emoji_manager import EMOJI_DIR + from src.chat.emoji_system.emoji_manager import get_emoji_manager + + # 确保目录存在 + os.makedirs(EMOJI_DIR, exist_ok=True) + + # 检查是否已存在该表情包（通过哈希值） + emoji_manager = get_emoji_manager() + existing_emoji = await emoji_manager.get_emoji_from_manager(image_hash) + if existing_emoji: + logger.debug(f"[自动保存] 表情包已注册，跳过保存: {image_hash[:8]}...") + return + + # 生成文件名：使用哈希值前8位 + 格式 + filename = f"{image_hash[:8]}.{image_format}" + file_path = os.path.join(EMOJI_DIR, filename) + + # 检查文件是否已存在（可能之前保存过但未注册） + if not os.path.exists(file_path): + # 保存文件 + if base64_to_image(image_base64, file_path): + logger.info(f"[自动保存] 表情包已保存到 {file_path} (Hash: {image_hash[:8]}...)") + else: + logger.warning(f"[自动保存] 保存表情包文件失败: {file_path}") + else: + logger.debug(f"[自动保存] 表情包文件已存在，跳过: {file_path}") + except Exception as save_error: + logger.warning(f"[自动保存] 保存表情包文件时出错: {save_error}") + async def get_emoji_description(self, image_base64: str) -> str: - """获取表情包描述，优先使用Emoji表中的缓存数据""" + """获取表情包描述，优先使用EmojiDescriptionCache表中的缓存数据""" try: # 计算图片哈希 # 确保base64字符串只包含ASCII字符 @@ -158,10 +227,29 @@ class ImageManager: except Exception as e: logger.debug(f"查询EmojiManager时出错: {e}") - # 查询ImageDescriptions表的缓存描述 - if cached_description := self._get_description_from_db(image_hash, "emoji"): - logger.info(f"[缓存命中] 使用ImageDescriptions表中的描述: {cached_description[:50]}...") - return f"[表情包：{cached_description}]" + # 查询EmojiDescriptionCache表的缓存（包含描述和情感标签） + try: + cache_record = EmojiDescriptionCache.get_or_none(EmojiDescriptionCache.emoji_hash == image_hash) + if cache_record: + # 优先使用情感标签，如果没有则使用详细描述 + result_text = "" + if cache_record.emotion_tags: + logger.info( + f"[缓存命中] 使用EmojiDescriptionCache表中的情感标签: {cache_record.emotion_tags[:50]}..." + ) + result_text = f"[表情包：{cache_record.emotion_tags}]" + elif cache_record.description: + logger.info( + f"[缓存命中] 使用EmojiDescriptionCache表中的描述: {cache_record.description[:50]}..." + ) + result_text = f"[表情包：{cache_record.description}]" + + # 即使缓存命中，如果启用了steal_emoji，也检查是否需要保存文件 + if result_text: + await self._save_emoji_file_if_needed(image_base64, image_hash, image_format) + return result_text + except Exception as e: + logger.debug(f"查询EmojiDescriptionCache时出错: {e}") # === 二步走识别流程 === @@ -221,45 +309,38 @@ class ImageManager: logger.debug(f"[emoji识别] 详细描述: {detailed_description[:50]}... -> 情感标签: {final_emotion}") - if cached_description := self._get_description_from_db(image_hash, "emoji"): - logger.warning(f"虽然生成了描述，但是找到缓存表情包描述: {cached_description}") - return f"[表情包：{cached_description}]" - - # 保存表情包文件和元数据（用于可能的后续分析） - logger.debug(f"保存表情包: {image_hash}") - current_timestamp = time.time() - filename = f"{int(current_timestamp)}_{image_hash[:8]}.{image_format}" - emoji_dir = os.path.join(self.IMAGE_DIR, "emoji") - os.makedirs(emoji_dir, exist_ok=True) - file_path = os.path.join(emoji_dir, filename) - + # 再次检查缓存（防止并发情况下其他线程已经保存） try: - # 保存文件 - with open(file_path, "wb") as f: - f.write(image_bytes) - - # 保存到数据库 (Images表) - 包含详细描述用于可能的注册流程 - try: - img_obj = Images.get((Images.emoji_hash == image_hash) & (Images.type == "emoji")) - img_obj.path = file_path - img_obj.description = detailed_description # 保存详细描述 - img_obj.timestamp = current_timestamp - img_obj.save() - except Images.DoesNotExist: # type: ignore - Images.create( - image_id=str(uuid.uuid4()), - emoji_hash=image_hash, - path=file_path, - type="emoji", - description=detailed_description, # 保存详细描述 - timestamp=current_timestamp, - vlm_processed=True, - ) + cache_record = EmojiDescriptionCache.get_or_none(EmojiDescriptionCache.emoji_hash == image_hash) + if cache_record and cache_record.emotion_tags: + logger.warning(f"虽然生成了描述，但是找到缓存表情包情感标签: {cache_record.emotion_tags}") + return f"[表情包：{cache_record.emotion_tags}]" except Exception as e: - logger.error(f"保存表情包文件或元数据失败: {str(e)}") + logger.debug(f"再次查询EmojiDescriptionCache时出错: {e}") - # 保存最终的情感标签到缓存 (ImageDescriptions表) - self._save_description_to_db(image_hash, final_emotion, "emoji") + # 保存识别出的详细描述和情感标签到 emoji_description_cache + try: + current_timestamp = time.time() + cache_record, created = EmojiDescriptionCache.get_or_create( + emoji_hash=image_hash, + defaults={ + "description": detailed_description, + "emotion_tags": final_emotion, + "timestamp": current_timestamp, + }, + ) + if not created: + # 更新已有记录 + cache_record.description = detailed_description + cache_record.emotion_tags = final_emotion + cache_record.timestamp = current_timestamp + cache_record.save() + logger.info(f"[缓存保存] 表情包描述和情感标签已保存到EmojiDescriptionCache: {image_hash[:8]}...") + except Exception as e: + logger.error(f"保存表情包描述和情感标签缓存失败: {str(e)}") + + # 如果启用了steal_emoji，自动保存表情包文件到data/emoji目录 + await self._save_emoji_file_if_needed(image_base64, image_hash, image_format) return f"[表情包：{final_emotion}]" diff --git a/src/common/data_models/database_data_model.py b/src/common/data_models/database_data_model.py index b981bd33..5bd35873 100644 --- a/src/common/data_models/database_data_model.py +++ b/src/common/data_models/database_data_model.py @@ -77,6 +77,7 @@ class DatabaseMessages(BaseDataModel): is_emoji: bool = False, is_picid: bool = False, is_command: bool = False, + intercept_message_level: int = 0, is_notify: bool = False, selected_expressions: Optional[str] = None, user_id: str = "", @@ -119,6 +120,7 @@ class DatabaseMessages(BaseDataModel): self.is_emoji = is_emoji self.is_picid = is_picid self.is_command = is_command + self.intercept_message_level = intercept_message_level self.is_notify = is_notify self.selected_expressions = selected_expressions @@ -186,6 +188,7 @@ class DatabaseMessages(BaseDataModel): "is_emoji": self.is_emoji, "is_picid": self.is_picid, "is_command": self.is_command, + "intercept_message_level": self.intercept_message_level, "is_notify": self.is_notify, "selected_expressions": self.selected_expressions, "user_id": self.user_info.user_id, diff --git a/src/common/data_models/message_data_model.py b/src/common/data_models/message_data_model.py index a3d5751f..dc4ad951 100644 --- a/src/common/data_models/message_data_model.py +++ b/src/common/data_models/message_data_model.py @@ -21,6 +21,8 @@ class MessageAndActionModel(BaseDataModel): chat_info_platform: str = field(default_factory=str) is_action_record: bool = field(default=False) action_name: Optional[str] = None + is_command: bool = field(default=False) + intercept_message_level: int = field(default=0) @classmethod def from_DatabaseMessages(cls, message: "DatabaseMessages"): @@ -34,6 +36,8 @@ class MessageAndActionModel(BaseDataModel): processed_plain_text=message.processed_plain_text, display_message=message.display_message, chat_info_platform=message.chat_info.platform, + is_command=message.is_command, + intercept_message_level=getattr(message, "intercept_message_level", 0), ) diff --git a/src/common/database/database_model.py b/src/common/database/database_model.py index c97c0b72..a59f68e2 100644 --- a/src/common/database/database_model.py +++ b/src/common/database/database_model.py @@ -170,6 +170,7 @@ class Messages(BaseModel): is_emoji = BooleanField(default=False) is_picid = BooleanField(default=False) is_command = BooleanField(default=False) + intercept_message_level = IntegerField(default=0) is_notify = BooleanField(default=False) selected_expressions = TextField(null=True) @@ -239,6 +240,20 @@ class ImageDescriptions(BaseModel): table_name = "image_descriptions" +class EmojiDescriptionCache(BaseModel): + """ + 存储表情包的详细描述和情感标签缓存 + """ + + emoji_hash = TextField(unique=True, index=True) + description = TextField() # 详细描述 + emotion_tags = TextField(null=True) # 情感标签，逗号分隔 + timestamp = FloatField() + + class Meta: + table_name = "emoji_description_cache" + + class OnlineTime(BaseModel): """ 用于存储在线时长记录的模型。 @@ -309,13 +324,15 @@ class Expression(BaseModel): # new mode fields context = TextField(null=True) - up_content = TextField(null=True) content_list = TextField(null=True) + style_list = TextField(null=True) # 存储相似的 style，格式与 content_list 相同（JSON 数组） count = IntegerField(default=1) last_active_time = FloatField() chat_id = TextField(index=True) create_date = FloatField(null=True) # 创建日期，允许为空以兼容老数据 + checked = BooleanField(default=False) # 是否已检查 + rejected = BooleanField(default=False) # 是否被拒绝但未更新 class Meta: table_name = "expression" @@ -328,8 +345,6 @@ class Jargon(BaseModel): content = TextField() raw_content = TextField(null=True) - type = TextField(null=True) - translation = TextField(null=True) meaning = TextField(null=True) chat_id = TextField(index=True) is_global = BooleanField(default=False) @@ -357,6 +372,7 @@ class ChatHistory(BaseModel): theme = TextField() # 主题：这段对话的主要内容，一个简短的标题 keywords = TextField() # 关键词：这段对话的关键词，JSON格式存储 summary = TextField() # 概括：对这段话的平文本概括 + key_point = TextField(null=True) # 关键信息：话题中的关键信息点，JSON格式存储 count = IntegerField(default=0) # 被检索次数 forget_times = IntegerField(default=0) # 被遗忘检查的次数 @@ -389,6 +405,7 @@ MODELS = [ Messages, Images, ImageDescriptions, + EmojiDescriptionCache, OnlineTime, PersonInfo, Expression, @@ -576,22 +593,41 @@ def _fix_table_constraints(table_name, model, constraints_to_fix): db.execute_sql(f"CREATE TABLE {backup_table} AS SELECT * FROM {table_name}") logger.info(f"已创建备份表 '{backup_table}'") - # 2. 删除原表 + # 2. 获取原始行数（在删除表之前） + original_count = db.execute_sql(f"SELECT COUNT(*) FROM {backup_table}").fetchone()[0] + logger.info(f"备份表 '{backup_table}' 包含 {original_count} 行数据") + + # 3. 删除原表 db.execute_sql(f"DROP TABLE {table_name}") logger.info(f"已删除原表 '{table_name}'") - # 3. 重新创建表（使用当前模型定义） + # 4. 重新创建表（使用当前模型定义） db.create_tables([model]) logger.info(f"已重新创建表 '{table_name}' 使用新的约束") - # 4. 从备份表恢复数据 - # 获取字段列表 + # 5. 从备份表恢复数据 + # 获取字段列表，排除主键字段（让数据库自动生成新的主键） fields = list(model._meta.fields.keys()) - fields_str = ", ".join(fields) + # Peewee 默认使用 'id' 作为主键字段名 + # 尝试获取主键字段名，如果获取失败则默认使用 'id' + primary_key_name = "id" # 默认值 + try: + if hasattr(model._meta, "primary_key") and model._meta.primary_key: + if hasattr(model._meta.primary_key, "name"): + primary_key_name = model._meta.primary_key.name + elif isinstance(model._meta.primary_key, str): + primary_key_name = model._meta.primary_key + except Exception: + pass # 如果获取失败，使用默认值 'id' - # 对于需要从 NOT NULL 改为 NULL 的字段，直接复制数据 - # 对于需要从 NULL 改为 NOT NULL 的字段，需要处理 NULL 值 - insert_sql = f"INSERT INTO {table_name} ({fields_str}) SELECT {fields_str} FROM {backup_table}" + # 如果字段列表包含主键，则排除它 + if primary_key_name in fields: + fields_without_pk = [f for f in fields if f != primary_key_name] + logger.info(f"排除主键字段 '{primary_key_name}'，让数据库自动生成新的主键") + else: + fields_without_pk = fields + + fields_str = ", ".join(fields_without_pk) # 检查是否有字段需要从 NULL 改为 NOT NULL null_to_notnull_fields = [ @@ -604,7 +640,7 @@ def _fix_table_constraints(table_name, model, constraints_to_fix): # 构建更复杂的 SELECT 语句来处理 NULL 值 select_fields = [] - for field_name in fields: + for field_name in fields_without_pk: if field_name in null_to_notnull_fields: field_obj = model._meta.fields[field_name] # 根据字段类型设置默认值 @@ -625,12 +661,13 @@ def _fix_table_constraints(table_name, model, constraints_to_fix): select_str = ", ".join(select_fields) insert_sql = f"INSERT INTO {table_name} ({fields_str}) SELECT {select_str} FROM {backup_table}" + else: + # 没有需要处理 NULL 的字段，直接复制数据（排除主键） + insert_sql = f"INSERT INTO {table_name} ({fields_str}) SELECT {fields_str} FROM {backup_table}" db.execute_sql(insert_sql) logger.info(f"已从备份表恢复数据到 '{table_name}'") - # 5. 验证数据完整性 - original_count = db.execute_sql(f"SELECT COUNT(*) FROM {backup_table}").fetchone()[0] new_count = db.execute_sql(f"SELECT COUNT(*) FROM {table_name}").fetchone()[0] if original_count == new_count: diff --git a/src/common/logger.py b/src/common/logger.py index 4cf40398..b57c9dd3 100644 --- a/src/common/logger.py +++ b/src/common/logger.py @@ -20,6 +20,9 @@ PROJECT_ROOT = logger_file.parent.parent.parent.resolve() _file_handler = None _console_handler = None _ws_handler = None +# 全局标志，防止重复初始化 +_logging_initialized = False +_cleanup_task_started = False def get_file_handler(): @@ -869,29 +872,41 @@ def get_logger(name: Optional[str]) -> structlog.stdlib.BoundLogger: return logger -def initialize_logging(): +def initialize_logging(verbose: bool = True): """手动初始化日志系统，确保所有logger都使用正确的配置 在应用程序的早期调用此函数，确保所有模块都使用统一的日志配置 + + Args: + verbose: 是否输出详细的初始化信息。默认为 True。 + 在 Runner 进程中可以设置为 False 以避免重复的初始化日志。 """ - global LOG_CONFIG + global LOG_CONFIG, _logging_initialized + + # 防止重复初始化（在同一进程内） + if _logging_initialized: + return + + _logging_initialized = True + LOG_CONFIG = load_log_config() # print(LOG_CONFIG) configure_third_party_loggers() reconfigure_existing_loggers() # 启动日志清理任务 - start_log_cleanup_task() + start_log_cleanup_task(verbose=verbose) - # 输出初始化信息 - logger = get_logger("logger") - console_level = LOG_CONFIG.get("console_log_level", LOG_CONFIG.get("log_level", "INFO")) - file_level = LOG_CONFIG.get("file_log_level", LOG_CONFIG.get("log_level", "INFO")) + # 只在 verbose=True 时输出详细的初始化信息 + if verbose: + logger = get_logger("logger") + console_level = LOG_CONFIG.get("console_log_level", LOG_CONFIG.get("log_level", "INFO")) + file_level = LOG_CONFIG.get("file_log_level", LOG_CONFIG.get("log_level", "INFO")) - logger.info("日志系统已初始化:") - logger.info(f" - 控制台级别: {console_level}") - logger.info(f" - 文件级别: {file_level}") - logger.info(" - 轮转份数: 30个文件|自动清理: 30天前的日志") + logger.info("日志系统已初始化:") + logger.info(f" - 控制台级别: {console_level}") + logger.info(f" - 文件级别: {file_level}") + logger.info(" - 轮转份数: 30个文件|自动清理: 30天前的日志") def cleanup_old_logs(): @@ -924,8 +939,19 @@ def cleanup_old_logs(): logger.error(f"清理旧日志文件时出错: {e}") -def start_log_cleanup_task(): - """启动日志清理任务""" +def start_log_cleanup_task(verbose: bool = True): + """启动日志清理任务 + + Args: + verbose: 是否输出启动信息。默认为 True。 + """ + global _cleanup_task_started + + # 防止重复启动清理任务 + if _cleanup_task_started: + return + + _cleanup_task_started = True def cleanup_task(): while True: @@ -935,8 +961,9 @@ def start_log_cleanup_task(): cleanup_thread = threading.Thread(target=cleanup_task, daemon=True) cleanup_thread.start() - logger = get_logger("logger") - logger.info("已启动日志清理任务，将自动清理30天前的日志文件（轮转份数限制: 30个文件）") + if verbose: + logger = get_logger("logger") + logger.info("已启动日志清理任务，将自动清理30天前的日志文件（轮转份数限制: 30个文件）") def shutdown_logging(): diff --git a/src/common/message/api.py b/src/common/message/api.py index eed85c0a..f9f6c8f5 100644 --- a/src/common/message/api.py +++ b/src/common/message/api.py @@ -15,14 +15,18 @@ def get_global_api() -> MessageServer: # sourcery skip: extract-method # 检查maim_message版本 try: maim_message_version = importlib.metadata.version("maim_message") - version_compatible = [int(x) for x in maim_message_version.split(".")] >= [0, 3, 3] + version_int = [int(x) for x in maim_message_version.split(".")] + version_compatible = version_int >= [0, 3, 3] + # Check for API Server feature (>= 0.6.0) + has_api_server_feature = version_int >= [0, 6, 0] except (importlib.metadata.PackageNotFoundError, ValueError): version_compatible = False + has_api_server_feature = False # 读取配置项 maim_message_config = global_config.maim_message - # 设置基本参数 + # 设置基本参数 (Legacy Server Mode) kwargs = { "host": os.environ["HOST"], "port": int(os.environ["PORT"]), @@ -39,21 +43,129 @@ def get_global_api() -> MessageServer: # sourcery skip: extract-method if maim_message_config.auth_token and len(maim_message_config.auth_token) > 0: kwargs["enable_token"] = True - if maim_message_config.use_custom: - # 添加WSS模式支持 - del kwargs["app"] - kwargs["host"] = maim_message_config.host - kwargs["port"] = maim_message_config.port - kwargs["mode"] = maim_message_config.mode - if maim_message_config.use_wss: - if maim_message_config.cert_file: - kwargs["ssl_certfile"] = maim_message_config.cert_file - if maim_message_config.key_file: - kwargs["ssl_keyfile"] = maim_message_config.key_file - kwargs["enable_custom_uvicorn_logger"] = False + # Removed legacy custom config block (use_custom) as requested. + kwargs["enable_custom_uvicorn_logger"] = False global_api = MessageServer(**kwargs) if version_compatible and maim_message_config.auth_token: for token in maim_message_config.auth_token: global_api.add_valid_token(token) + + # --------------------------------------------------------------------- + # Additional API Server Configuration (maim_message >= 6.0) + # --------------------------------------------------------------------- + enable_api_server = maim_message_config.enable_api_server + + # 如果版本支持且启用了API Server，则初始化额外服务器 + if has_api_server_feature and enable_api_server: + try: + from maim_message.server import WebSocketServer, ServerConfig + from maim_message.message import APIMessageBase + + api_logger = get_logger("maim_message_api_server") + + # 1. Prepare Config + api_server_host = maim_message_config.api_server_host + api_server_port = maim_message_config.api_server_port + use_wss = maim_message_config.api_server_use_wss + + server_config = ServerConfig( + host=api_server_host, + port=api_server_port, + ssl_enabled=use_wss, + ssl_certfile=maim_message_config.api_server_cert_file if use_wss else None, + ssl_keyfile=maim_message_config.api_server_key_file if use_wss else None, + ) + + # 2. Setup Auth Handler + async def auth_handler(metadata: dict) -> bool: + allowed_keys = maim_message_config.api_server_allowed_api_keys + # If list is empty/None, allow all (default behavior of returning True) + if not allowed_keys: + return True + + api_key = metadata.get("api_key") + if api_key in allowed_keys: + return True + + api_logger.warning(f"Rejected connection with invalid API Key: {api_key}") + return False + + server_config.on_auth = auth_handler + + # 3. Setup Message Bridge + # Initialize refined route map if not exists + if not hasattr(global_api, "platform_map"): + global_api.platform_map = {} + + async def bridge_message_handler(message: APIMessageBase, metadata: dict): + # Bridge message to the main bot logic + # We convert APIMessageBase to dict to be compatible with legacy handlers + # that MainBot (ChatManager) expects. + msg_dict = message.to_dict() + + # Compatibility Layer: Flatten sender_info to top-level user_info/group_info + # Legacy MessageBase expects message_info to have user_info and group_info directly. + if "message_info" in msg_dict: + msg_info = msg_dict["message_info"] + sender_info = msg_info.get("sender_info") + if sender_info: + # If direct user_info/group_info are missing, populate them from sender_info + if "user_info" not in msg_info and (ui := sender_info.get("user_info")): + msg_info["user_info"] = ui + + if "group_info" not in msg_info and (gi := sender_info.get("group_info")): + msg_info["group_info"] = gi + + # Route Caching Logic: Simply map platform to API Key + # This allows us to send messages back to the correct API client for this platform + try: + api_key = metadata.get("api_key") + if api_key: + platform = msg_info.get("platform") + if platform: + global_api.platform_map[platform] = api_key + except Exception as e: + api_logger.warning(f"Failed to update platform map: {e}") + + # Compatibility Layer: Ensure raw_message exists (even if None) as it's part of MessageBase + if "raw_message" not in msg_dict: + msg_dict["raw_message"] = None + + await global_api.process_message(msg_dict) + + server_config.on_message = bridge_message_handler + + # 4. Initialize Server + extra_server = WebSocketServer(config=server_config) + + # 5. Patch global_api lifecycle methods to manage both servers + original_run = global_api.run + original_stop = global_api.stop + + async def patched_run(): + api_logger.info(f"Starting Additional API Server on {api_server_host}:{api_server_port} (WSS: {use_wss})") + # Start the extra server (non-blocking start) + await extra_server.start() + # Run the original legacy server (this usually keeps running) + await original_run() + + async def patched_stop(): + api_logger.info("Stopping Additional API Server...") + await extra_server.stop() + await original_stop() + + global_api.run = patched_run + global_api.stop = patched_stop + + # Attach for reference + global_api.extra_server = extra_server + + except ImportError: + get_logger("maim_message").error("Cannot import maim_message.server components. Is maim_message >= 0.6.0 installed?") + except Exception as e: + get_logger("maim_message").error(f"Failed to initialize Additional API Server: {e}") + import traceback + get_logger("maim_message").debug(traceback.format_exc()) + return global_api diff --git a/src/common/message_repository.py b/src/common/message_repository.py index fb9120ac..fa0126d4 100644 --- a/src/common/message_repository.py +++ b/src/common/message_repository.py @@ -25,6 +25,7 @@ def find_messages( limit_mode: str = "latest", filter_bot=False, filter_command=False, + filter_intercept_message_level: Optional[int] = None, ) -> List[DatabaseMessages]: """ 根据提供的过滤器、排序和限制条件查找消息。 @@ -84,6 +85,10 @@ def find_messages( # 使用按位取反构造 Peewee 的 NOT 条件，避免直接与 False 比较 query = query.where(~Messages.is_command) + if filter_intercept_message_level is not None: + # 过滤掉所有 intercept_message_level > filter_intercept_message_level 的消息 + query = query.where(Messages.intercept_message_level <= filter_intercept_message_level) + if limit > 0: if limit_mode == "earliest": # 获取时间最早的 limit 条记录，已经是正序 diff --git a/src/common/toml_utils.py b/src/common/toml_utils.py new file mode 100644 index 00000000..6a7b8bb9 --- /dev/null +++ b/src/common/toml_utils.py @@ -0,0 +1,125 @@ +""" +TOML 工具函数 + +提供 TOML 文件的格式化保存功能，确保数组等元素以美观的多行格式输出。 +""" + +import re +from typing import Any +import tomlkit +from tomlkit.items import AoT, Table, Array + + +def _format_toml_value(obj: Any, threshold: int, depth: int = 0) -> Any: + """递归格式化 TOML 值，将数组转换为多行格式""" + # 处理 AoT (Array of Tables) - 保持原样，递归处理内部 + if isinstance(obj, AoT): + for item in obj: + _format_toml_value(item, threshold, depth) + return obj + + # 处理字典类型 (dict 或 Table) + if isinstance(obj, (dict, Table)): + for k, v in obj.items(): + obj[k] = _format_toml_value(v, threshold, depth) + return obj + + # 处理列表类型 (list 或 Array) + if isinstance(obj, (list, Array)): + # 如果是纯 list (非 tomlkit Array) 且包含字典/表，视为 AoT 的列表形式 + # 保持结构递归处理，避免转换为 Inline Table Array (因为 Inline Table 必须单行，复杂对象不友好) + if isinstance(obj, list) and not isinstance(obj, Array) and obj and isinstance(obj[0], (dict, Table)): + for i, item in enumerate(obj): + obj[i] = _format_toml_value(item, threshold, depth) + return obj + + # 决定是否多行：仅在顶层且长度超过阈值时 + should_multiline = depth == 0 and len(obj) > threshold + + # 如果已经是 tomlkit Array，原地修改以保留注释 + if isinstance(obj, Array): + obj.multiline(should_multiline) + for i, item in enumerate(obj): + obj[i] = _format_toml_value(item, threshold, depth + 1) + return obj + + # 普通 list：转换为 tomlkit 数组 + arr = tomlkit.array() + arr.multiline(should_multiline) + + for item in obj: + arr.append(_format_toml_value(item, threshold, depth + 1)) + return arr + + # 其他基本类型直接返回 + return obj + + +def _update_toml_doc(target: Any, source: Any) -> None: + """ + 递归合并字典，将 source 的值更新到 target 中，保留 target 的注释和格式。 + - 已存在的键：更新值（递归处理嵌套字典） + - 新增的键：添加到 target + - 跳过 version 字段 + """ + if isinstance(source, list) or not isinstance(source, dict) or not isinstance(target, dict): + return + + for key, value in source.items(): + if key == "version": + continue + if key in target: + # 已存在的键：递归更新或直接赋值 + target_value = target[key] + if isinstance(value, dict) and isinstance(target_value, dict): + _update_toml_doc(target_value, value) + else: + try: + target[key] = tomlkit.item(value) + except (TypeError, ValueError): + target[key] = value + else: + # 新增的键：添加到 target + try: + target[key] = tomlkit.item(value) + except (TypeError, ValueError): + target[key] = value + + +def save_toml_with_format( + data: Any, file_path: str, multiline_threshold: int = 1, preserve_comments: bool = True +) -> None: + """ + 格式化 TOML 数据并保存到文件。 + + Args: + data: 要保存的数据（dict 或 tomlkit 文档） + file_path: 保存路径 + multiline_threshold: 数组多行格式化阈值，-1 表示不格式化 + preserve_comments: 是否保留原文件的注释和格式（默认 True） + 若为 True 且文件已存在且 data 不是 tomlkit 文档，会先读取原文件，再将 data 合并进去 + """ + import os + from tomlkit import TOMLDocument + + # 如果需要保留注释、文件存在、且 data 不是已有的 tomlkit 文档，先读取原文件再合并 + if preserve_comments and os.path.exists(file_path) and not isinstance(data, TOMLDocument): + with open(file_path, "r", encoding="utf-8") as f: + doc = tomlkit.load(f) + _update_toml_doc(doc, data) + data = doc + + formatted = _format_toml_value(data, multiline_threshold) if multiline_threshold >= 0 else data + output = tomlkit.dumps(formatted) + # 规范化：将 3+ 连续空行压缩为 1 个空行，防止空行累积 + output = re.sub(r"\n{3,}", "\n\n", output) + with open(file_path, "w", encoding="utf-8") as f: + f.write(output) + + +def format_toml_string(data: Any, multiline_threshold: int = 1) -> str: + """格式化 TOML 数据并返回字符串""" + formatted = _format_toml_value(data, multiline_threshold) if multiline_threshold >= 0 else data + output = tomlkit.dumps(formatted) + # 规范化：将 3+ 连续空行压缩为 1 个空行，防止空行累积 + return re.sub(r"\n{3,}", "\n\n", output) diff --git a/src/config/api_ada_configs.py b/src/config/api_ada_configs.py index 3fc9c878..a5d5f059 100644 --- a/src/config/api_ada_configs.py +++ b/src/config/api_ada_configs.py @@ -60,6 +60,12 @@ class ModelInfo(ConfigBase): price_out: float = field(default=0.0) """每M token输出价格""" + temperature: float | None = field(default=None) + """模型级别温度（可选），会覆盖任务配置中的温度""" + + max_tokens: int | None = field(default=None) + """模型级别最大token数（可选），会覆盖任务配置中的max_tokens""" + force_stream_mode: bool = field(default=False) """是否强制使用流式输出模式""" @@ -88,6 +94,9 @@ class TaskConfig(ConfigBase): temperature: float = 0.3 """模型温度""" + slow_threshold: float = 15.0 + """慢请求阈值（秒），超过此值会输出警告日志""" + @dataclass class ModelTaskConfig(ConfigBase): diff --git a/src/config/config.py b/src/config/config.py index 01b9f6ca..4001d4ff 100644 --- a/src/config/config.py +++ b/src/config/config.py @@ -11,6 +11,7 @@ from rich.traceback import install from typing import List, Optional from src.common.logger import get_logger +from src.common.toml_utils import format_toml_string from src.config.config_base import ConfigBase from src.config.official_configs import ( BotConfig, @@ -30,10 +31,10 @@ from src.config.official_configs import ( RelationshipConfig, ToolConfig, VoiceConfig, - MoodConfig, MemoryConfig, DebugConfig, - JargonConfig, + DreamConfig, + WebUIConfig, ) from .api_ada_configs import ( @@ -56,7 +57,7 @@ TEMPLATE_DIR = os.path.join(PROJECT_ROOT, "template") # 考虑到，实际上配置文件中的mai_version是不会自动更新的,所以采用硬编码 # 对该字段的更新，请严格参照语义化版本规范：https://semver.org/lang/zh-CN/ -MMC_VERSION = "0.11.5" +MMC_VERSION = "0.12.0" def get_key_comment(toml_table, key): @@ -252,7 +253,7 @@ def _update_config_generic(config_name: str, template_name: str): # 如果配置有更新，立即保存到文件 if config_updated: with open(old_config_path, "w", encoding="utf-8") as f: - f.write(tomlkit.dumps(old_config)) + f.write(format_toml_string(old_config)) logger.info(f"已保存更新后的{config_name}配置文件") else: logger.info(f"未检测到{config_name}模板默认值变动") @@ -313,9 +314,9 @@ def _update_config_generic(config_name: str, template_name: str): logger.info(f"开始合并{config_name}新旧配置...") _update_dict(new_config, old_config) - # 保存更新后的配置（保留注释和格式） + # 保存更新后的配置（保留注释和格式，数组多行格式化） with open(new_config_path, "w", encoding="utf-8") as f: - f.write(tomlkit.dumps(new_config)) + f.write(format_toml_string(new_config)) logger.info(f"{config_name}配置文件更新完成，建议检查新配置文件中的内容，以免丢失重要信息") @@ -347,15 +348,15 @@ class Config(ConfigBase): response_post_process: ResponsePostProcessConfig response_splitter: ResponseSplitterConfig telemetry: TelemetryConfig + webui: WebUIConfig experimental: ExperimentalConfig maim_message: MaimMessageConfig lpmm_knowledge: LPMMKnowledgeConfig tool: ToolConfig memory: MemoryConfig debug: DebugConfig - mood: MoodConfig voice: VoiceConfig - jargon: JargonConfig + dream: DreamConfig @dataclass diff --git a/src/config/official_configs.py b/src/config/official_configs.py index fc084ecb..38665e6d 100644 --- a/src/config/official_configs.py +++ b/src/config/official_configs.py @@ -43,10 +43,13 @@ class PersonalityConfig(ConfigBase): """人格""" reply_style: str = "" - """表达风格""" + """默认表达风格""" - interest: str = "" - """兴趣""" + multiple_reply_style: list[str] = field(default_factory=lambda: []) + """可选的多种表达风格列表，当配置不为空时可按概率随机替换 reply_style""" + + multiple_probability: float = 0.0 + """每次构建回复时，从 multiple_reply_style 中随机替换 reply_style 的概率（0.0-1.0）""" plan_style: str = "" """说话规则，行为风格""" @@ -79,12 +82,6 @@ class ChatConfig(ConfigBase): max_context_size: int = 18 """上下文长度""" - interest_rate_mode: Literal["fast", "accurate"] = "fast" - """兴趣值计算模式，fast为快速计算，accurate为精确计算""" - - planner_size: float = 1.5 - """副规划器大小，越小，麦麦的动作执行能力越精细，但是消耗更多token，调大可以缓解429类错误""" - mentioned_bot_reply: bool = True """是否启用提及必回复""" @@ -117,8 +114,13 @@ class ChatConfig(ConfigBase): 时间区间支持跨夜，例如 "23:00-02:00"。 """ - include_planner_reasoning: bool = False - """是否将planner推理加入replyer，默认关闭（不加入）""" + think_mode: Literal["classic", "deep", "dynamic"] = "classic" + """ + 思考模式配置 + - classic: 默认think_level为0（轻量回复，不需要思考和回忆） + - deep: 默认think_level为1（深度回复，需要进行回忆和思考） + - dynamic: think_level由planner动态给出（根据planner返回的think_level决定） + """ def _parse_stream_config_to_chat_id(self, stream_config_str: str) -> Optional[str]: """与 ChatStream.get_stream_id 一致地从 "platform:id:type" 生成 chat_id。""" @@ -133,14 +135,9 @@ class ChatConfig(ConfigBase): is_group = stream_type == "group" - import hashlib + from src.chat.message_receive.chat_stream import get_chat_manager - if is_group: - components = [platform, str(id_str)] - else: - components = [platform, str(id_str), "private"] - key = "_".join(components) - return hashlib.md5(key.encode()).hexdigest() + return get_chat_manager().get_stream_id(platform, str(id_str), is_group=is_group) except (ValueError, IndexError): return None @@ -173,7 +170,11 @@ class ChatConfig(ConfigBase): def get_talk_value(self, chat_id: Optional[str]) -> float: """根据规则返回当前 chat 的动态 talk_value，未匹配则回退到基础值。""" if not self.enable_talk_value_rules or not self.talk_value_rules: - return self.talk_value + result = self.talk_value + # 防止返回0值，自动转换为0.0001 + if result == 0: + return 0.0000001 + return result now_min = self._now_minutes() @@ -199,7 +200,11 @@ class ChatConfig(ConfigBase): start_min, end_min = parsed if self._in_range(now_min, start_min, end_min): try: - return float(value) + result = float(value) + # 防止返回0值，自动转换为0.0001 + if result == 0: + return 0.0000001 + return result except Exception: continue @@ -218,12 +223,20 @@ class ChatConfig(ConfigBase): start_min, end_min = parsed if self._in_range(now_min, start_min, end_min): try: - return float(value) + result = float(value) + # 防止返回0值，自动转换为0.0001 + if result == 0: + return 0.0000001 + return result except Exception: continue # 3) 未命中规则返回基础值 - return self.talk_value + result = self.talk_value + # 防止返回0值，自动转换为0.0001 + if result == 0: + return 0.0000001 + return result @dataclass @@ -244,10 +257,21 @@ class MemoryConfig(ConfigBase): max_agent_iterations: int = 5 """Agent最多迭代轮数（最低为1）""" + agent_timeout_seconds: float = 120.0 + """Agent超时时间（秒）""" + + enable_jargon_detection: bool = True + """记忆检索过程中是否启用黑话识别""" + + global_memory: bool = False + """是否允许记忆检索在聊天记录中进行全局查询（忽略当前chat_id，仅对 search_chat_history 等工具生效）""" + def __post_init__(self): """验证配置值""" if self.max_agent_iterations < 1: raise ValueError(f"max_agent_iterations 必须至少为1，当前值: {self.max_agent_iterations}") + if self.agent_timeout_seconds <= 0: + raise ValueError(f"agent_timeout_seconds 必须大于0，当前值: {self.agent_timeout_seconds}") @dataclass @@ -257,20 +281,20 @@ class ExpressionConfig(ConfigBase): learning_list: list[list] = field(default_factory=lambda: []) """ 表达学习配置列表，支持按聊天流配置 - 格式: [["chat_stream_id", "use_expression", "enable_learning", learning_intensity], ...] + 格式: [["chat_stream_id", "use_expression", "enable_learning", "enable_jargon_learning"], ...] 示例: [ - ["", "enable", "enable", 1.0], # 全局配置：使用表达，启用学习，学习强度1.0 - ["qq:1919810:private", "enable", "enable", 1.5], # 特定私聊配置：使用表达，启用学习，学习强度1.5 - ["qq:114514:private", "enable", "disable", 0.5], # 特定私聊配置：使用表达，禁用学习，学习强度0.5 + ["", "enable", "enable", "enable"], # 全局配置：使用表达，启用学习，启用jargon学习 + ["qq:1919810:private", "enable", "enable", "enable"], # 特定私聊配置：使用表达，启用学习，启用jargon学习 + ["qq:114514:private", "enable", "disable", "disable"], # 特定私聊配置：使用表达，禁用学习，禁用jargon学习 ] 说明: - 第一位: chat_stream_id，空字符串表示全局配置 - 第二位: 是否使用学到的表达 ("enable"/"disable") - 第三位: 是否学习表达 ("enable"/"disable") - - 第四位: 学习强度（浮点数），影响学习频率，最短学习时间间隔 = 300/学习强度（秒） + - 第四位: 是否启用jargon学习 ("enable"/"disable") """ expression_groups: list[list[str]] = field(default_factory=list) @@ -279,6 +303,33 @@ class ExpressionConfig(ConfigBase): 格式: [["qq:12345:group", "qq:67890:private"]] """ + reflect: bool = False + """是否启用表达反思""" + + reflect_operator_id: str = "" + """表达反思操作员ID""" + + allow_reflect: list[str] = field(default_factory=list) + """ + 允许进行表达反思的聊天流ID列表 + 格式: ["qq:123456:private", "qq:654321:group", ...] + 只有在此列表中的聊天流才会提出问题并跟踪 + 如果列表为空，则所有聊天流都可以进行表达反思（前提是 reflect = true） + """ + + all_global_jargon: bool = False + """是否将所有新增的jargon项目默认为全局（is_global=True），chat_id记录第一次存储时的id。注意，此功能关闭后，已经记录的全局黑话不会改变，需要手动删除""" + + enable_jargon_explanation: bool = True + """是否在回复前尝试对上下文中的黑话进行解释（关闭可减少一次LLM调用，仅影响回复前的黑话匹配与解释，不影响黑话学习）""" + + jargon_mode: Literal["context", "planner"] = "context" + """ + 黑话解释来源模式： + - "context": 使用上下文自动匹配黑话并解释（原有模式） + - "planner": 仅使用 Planner 在 reply 动作中给出的 unknown_words 列表进行黑话检索 + """ + def _parse_stream_config_to_chat_id(self, stream_config_str: str) -> Optional[str]: """ 解析流配置字符串并生成对应的 chat_id @@ -301,20 +352,15 @@ class ExpressionConfig(ConfigBase): # 判断是否为群聊 is_group = stream_type == "group" - # 使用与 ChatStream.get_stream_id 相同的逻辑生成 chat_id - import hashlib + # 使用 ChatManager 提供的接口生成 chat_id，避免在此重复实现逻辑 + from src.chat.message_receive.chat_stream import get_chat_manager - if is_group: - components = [platform, str(id_str)] - else: - components = [platform, str(id_str), "private"] - key = "_".join(components) - return hashlib.md5(key.encode()).hexdigest() + return get_chat_manager().get_stream_id(platform, str(id_str), is_group=is_group) except (ValueError, IndexError): return None - def get_expression_config_for_chat(self, chat_stream_id: Optional[str] = None) -> tuple[bool, bool, int]: + def get_expression_config_for_chat(self, chat_stream_id: Optional[str] = None) -> tuple[bool, bool, bool]: """ 根据聊天流ID获取表达配置 @@ -322,11 +368,11 @@ class ExpressionConfig(ConfigBase): chat_stream_id: 聊天流ID，格式为哈希值 Returns: - tuple: (是否使用表达, 是否学习表达, 学习间隔) + tuple: (是否使用表达, 是否学习表达, 是否启用jargon学习) """ if not self.learning_list: - # 如果没有配置，使用默认值：启用表达，启用学习，300秒间隔 - return True, True, 300 + # 如果没有配置，使用默认值：启用表达，启用学习，启用jargon学习 + return True, True, True # 优先检查聊天流特定的配置 if chat_stream_id: @@ -339,10 +385,10 @@ class ExpressionConfig(ConfigBase): if global_expression_config is not None: return global_expression_config - # 如果都没有匹配，返回默认值 - return True, True, 300 + # 如果都没有匹配，返回默认值：启用表达，启用学习，启用jargon学习 + return True, True, True - def _get_stream_specific_config(self, chat_stream_id: str) -> Optional[tuple[bool, bool, int]]: + def _get_stream_specific_config(self, chat_stream_id: str) -> Optional[tuple[bool, bool, bool]]: """ 获取特定聊天流的表达配置 @@ -350,7 +396,7 @@ class ExpressionConfig(ConfigBase): chat_stream_id: 聊天流ID（哈希值） Returns: - tuple: (是否使用表达, 是否学习表达, 学习间隔)，如果没有配置则返回 None + tuple: (是否使用表达, 是否学习表达, 是否启用jargon学习)，如果没有配置则返回 None """ for config_item in self.learning_list: if not config_item or len(config_item) < 4: @@ -375,19 +421,19 @@ class ExpressionConfig(ConfigBase): try: use_expression: bool = config_item[1].lower() == "enable" enable_learning: bool = config_item[2].lower() == "enable" - learning_intensity: float = float(config_item[3]) - return use_expression, enable_learning, learning_intensity # type: ignore + enable_jargon_learning: bool = config_item[3].lower() == "enable" + return use_expression, enable_learning, enable_jargon_learning # type: ignore except (ValueError, IndexError): continue return None - def _get_global_config(self) -> Optional[tuple[bool, bool, int]]: + def _get_global_config(self) -> Optional[tuple[bool, bool, bool]]: """ 获取全局表达配置 Returns: - tuple: (是否使用表达, 是否学习表达, 学习间隔)，如果没有配置则返回 None + tuple: (是否使用表达, 是否学习表达, 是否启用jargon学习)，如果没有配置则返回 None """ for config_item in self.learning_list: if not config_item or len(config_item) < 4: @@ -398,8 +444,8 @@ class ExpressionConfig(ConfigBase): try: use_expression: bool = config_item[1].lower() == "enable" enable_learning: bool = config_item[2].lower() == "enable" - learning_intensity = float(config_item[3]) - return use_expression, enable_learning, learning_intensity # type: ignore + enable_jargon_learning: bool = config_item[3].lower() == "enable" + return use_expression, enable_learning, enable_jargon_learning # type: ignore except (ValueError, IndexError): continue @@ -414,20 +460,6 @@ class ToolConfig(ConfigBase): """是否在聊天中启用工具""" -@dataclass -class MoodConfig(ConfigBase): - """情绪配置类""" - - enable_mood: bool = True - """是否启用情绪系统""" - - mood_update_threshold: float = 1 - """情绪更新阈值,越高，更新越慢""" - - emotion_style: str = "情绪较为稳定，但遭遇特定事件的时候起伏较大" - """情感特征，影响情绪的变化情况""" - - @dataclass class VoiceConfig(ConfigBase): """语音识别配置类""" @@ -565,6 +597,35 @@ class TelemetryConfig(ConfigBase): """是否启用遥测""" +@dataclass +class WebUIConfig(ConfigBase): + """WebUI配置类 + + 注意: host 和 port 配置已移至环境变量 WEBUI_HOST 和 WEBUI_PORT + """ + + enabled: bool = True + """是否启用WebUI""" + + mode: Literal["development", "production"] = "production" + """运行模式：development(开发) 或 production(生产)""" + + anti_crawler_mode: Literal["false", "strict", "loose", "basic"] = "basic" + """防爬虫模式：false(禁用) / strict(严格) / loose(宽松) / basic(基础-只记录不阻止)""" + + allowed_ips: str = "127.0.0.1" + """IP白名单（逗号分隔，支持精确IP、CIDR格式和通配符）""" + + trusted_proxies: str = "" + """信任的代理IP列表（逗号分隔），只有来自这些IP的X-Forwarded-For才被信任""" + + trust_xff: bool = False + """是否启用X-Forwarded-For代理解析（默认false）""" + + secure_cookie: bool = False + """是否启用安全Cookie（仅通过HTTPS传输，默认false）""" + + @dataclass class DebugConfig(ConfigBase): """调试配置类""" @@ -622,29 +683,29 @@ class ExperimentalConfig(ConfigBase): class MaimMessageConfig(ConfigBase): """maim_message配置类""" - use_custom: bool = False - """是否使用自定义的maim_message配置""" - - host: str = "127.0.0.1" - """主机地址""" - - port: int = 8090 - """"端口号""" - - mode: Literal["ws", "tcp"] = "ws" - """连接模式，支持ws和tcp""" - - use_wss: bool = False - """是否使用WSS安全连接""" - - cert_file: str = "" - """SSL证书文件路径，仅在use_wss=True时有效""" - - key_file: str = "" - """SSL密钥文件路径，仅在use_wss=True时有效""" - auth_token: list[str] = field(default_factory=lambda: []) - """认证令牌，用于API验证，为空则不启用验证""" + """认证令牌，用于旧版API验证，为空则不启用验证""" + + enable_api_server: bool = False + """是否启用额外的新版API Server""" + + api_server_host: str = "0.0.0.0" + """新版API Server主机地址""" + + api_server_port: int = 8090 + """新版API Server端口号""" + + api_server_use_wss: bool = False + """新版API Server是否启用WSS""" + + api_server_cert_file: str = "" + """新版API Server SSL证书文件路径""" + + api_server_key_file: str = "" + """新版API Server SSL密钥文件路径""" + + api_server_allowed_api_keys: list[str] = field(default_factory=lambda: []) + """新版API Server允许的API Key列表，为空则允许所有连接""" @dataclass @@ -690,10 +751,107 @@ class LPMMKnowledgeConfig(ConfigBase): embedding_dimension: int = 1024 """嵌入向量维度，应该与模型的输出维度一致""" + max_embedding_workers: int = 3 + """嵌入/抽取并发线程数""" + + embedding_chunk_size: int = 4 + """每批嵌入的条数""" + + max_synonym_entities: int = 2000 + """同义边参与的实体数上限，超限则跳过""" + + enable_ppr: bool = True + """是否启用PPR，低配机器可关闭""" + @dataclass -class JargonConfig(ConfigBase): - """Jargon配置类""" +class DreamConfig(ConfigBase): + """Dream配置类""" - all_global: bool = False - """是否将所有新增的jargon项目默认为全局（is_global=True），chat_id记录第一次存储时的id""" + interval_minutes: int = 30 + """做梦时间间隔（分钟），默认30分钟""" + + max_iterations: int = 20 + """做梦最大轮次，默认20轮""" + + first_delay_seconds: int = 60 + """程序启动后首次做梦前的延迟时间（秒），默认60秒""" + + dream_send: str = "" + """ + 做梦结果推送目标，格式为 "platform:user_id" + 例如: "qq:123456" 表示在做梦结束后，将梦境文本额外发送给该QQ私聊用户。 + 为空字符串时不推送。 + """ + + dream_time_ranges: list[str] = field(default_factory=lambda: []) + """ + 做梦时间段配置列表，格式：["HH:MM-HH:MM", ...] + 如果列表为空，则表示全天允许做梦。 + 如果配置了时间段，则只有在这些时间段内才会实际执行做梦流程。 + 时间段外，调度器仍会按间隔检查，但不会进入做梦流程。 + + 示例: + [ + "09:00-22:00", # 白天允许做梦 + "23:00-02:00", # 跨夜时间段（23:00到次日02:00） + ] + + 支持跨夜区间，例如 "23:00-02:00" 表示从23:00到次日02:00。 + """ + + 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 is_in_dream_time(self) -> bool: + """ + 检查当前时间是否在允许做梦的时间段内。 + 如果 dream_time_ranges 为空，则返回 True（全天允许）。 + """ + if not self.dream_time_ranges: + return True + + now_min = self._now_minutes() + + for time_range in self.dream_time_ranges: + if 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): + return True + + return False + + def __post_init__(self): + """验证配置值""" + if self.interval_minutes < 1: + raise ValueError(f"interval_minutes 必须至少为1，当前值: {self.interval_minutes}") + if self.max_iterations < 1: + raise ValueError(f"max_iterations 必须至少为1，当前值: {self.max_iterations}") + if self.first_delay_seconds < 0: + raise ValueError(f"first_delay_seconds 不能为负数，当前值: {self.first_delay_seconds}") diff --git a/src/dream/dream_agent.py b/src/dream/dream_agent.py new file mode 100644 index 00000000..b516a88e --- /dev/null +++ b/src/dream/dream_agent.py @@ -0,0 +1,580 @@ +import asyncio +import random +import time +from typing import Any, Dict, List, Optional, Tuple + +from peewee import fn + +from src.common.logger import get_logger +from src.config.config import global_config, model_config +from src.common.database.database_model import ChatHistory +from src.chat.utils.prompt_builder import Prompt, global_prompt_manager +from src.llm_models.payload_content.message import MessageBuilder, RoleType, Message +from src.plugin_system.apis import llm_api +from src.dream.dream_generator import generate_dream_summary + +# dream 工具工厂函数 +from src.dream.tools.search_chat_history_tool import make_search_chat_history +from src.dream.tools.get_chat_history_detail_tool import make_get_chat_history_detail +from src.dream.tools.delete_chat_history_tool import make_delete_chat_history +from src.dream.tools.create_chat_history_tool import make_create_chat_history +from src.dream.tools.update_chat_history_tool import make_update_chat_history +from src.dream.tools.finish_maintenance_tool import make_finish_maintenance +from src.dream.tools.search_jargon_tool import make_search_jargon +from src.dream.tools.delete_jargon_tool import make_delete_jargon +from src.dream.tools.update_jargon_tool import make_update_jargon + +logger = get_logger("dream_agent") + + +def init_dream_prompts() -> None: + """初始化 dream agent 的提示词""" + Prompt( + """ +你的名字是{bot_name}，你现在处于"梦境维护模式（dream agent）"。 +你可以自由地在 ChatHistory 库中探索、整理、创建和删改记录，以帮助自己在未来更好地回忆和理解对话历史。 + +本轮要维护的聊天ID：{chat_id} +本轮随机选中的起始记忆 ID：{start_memory_id} +请优先以这条起始记忆为切入点，先理解它的内容与上下文，再决定如何在其附近进行创建新概括、重写或删除等整理操作；如果起始记忆为空，则由你自行选择合适的切入点。 + +你可以使用的工具包括： +**ChatHistory 维护工具：** +- search_chat_history：根据关键词或参与人搜索该 chat_id 下的历史记忆概括列表 +- get_chat_history_detail：查看某条概括的详细内容 +- create_chat_history：根据整理后的理解创建一条新的 ChatHistory 概括记录（主题、概括、关键词、关键信息等） +- update_chat_history：在不改变事实的前提下重写或精炼主题、概括、关键词、关键信息 +- delete_chat_history：删除明显冗余、噪声、错误或无意义的记录，或者非常有时效性的信息，或者无太多有用信息的日常互动。 +你也可以先用 create_chat_history 创建一条新的综合概括，再对旧的冗余记录执行多次 delete_chat_history 来完成“合并”效果。 + +**Jargon（黑话）维护工具（只读，禁止修改）：** +- search_jargon：根据一个或多个关键词搜索Jargon 记录，通常是含义不明确的词条或者特殊的缩写 + +**通用工具：** +- finish_maintenance：当你认为当前维护工作已经完成，没有更多需要整理的内容时，调用此工具来结束本次运行 + +**工作目标**： +- 发现冗余、重复或高度相似的记录，并进行合并或删除； +- 发现主题/概括过于含糊、啰嗦或缺少关键信息的记录，进行重写和精简； +- summary要尽可能保持有用的信息； +- 尽量保持信息的真实与可用性，不要凭空捏造事实。 + +**合并准则** +- 你可以新建一个记录，然后删除旧记录来实现合并。 +- 如果两个或多个记录的主题相似，内容是对主题不同方面的信息或讨论，且信息量较少，则可以合并为一条记录。 +- 如果两个记录冲突，可以根据逻辑保留一个或者进行整合，也可以采取更新的记录，删除旧的记录 + +**轮次信息**： +- 本次维护最多执行 {max_iterations} 轮 +- 每轮开始时，系统会告知你当前是第几轮，还剩多少轮 +- 如果提前完成维护工作，可以调用 finish_maintenance 工具主动结束 + +**每一轮的执行方式（必须遵守）：** +- 第一步：先用一小段中文自然语言，写出你的「思考」和本轮计划（例如要查什么、准备怎么合并/修改）； +- 第二步：在这段思考之后，再通过工具调用来执行你的计划（可以调用 0~N 个工具）； +- 第三步：收到工具结果后，在下一轮继续先写出新的思考，再视情况继续调用工具。 + +请不要在没有先写出思考的情况下直接调用工具。 +只输出你的思考内容或工具调用结果，由系统负责真正执行工具调用。 +""", + name="dream_react_head_prompt", + ) + + +class DreamTool: + """dream 模块内部使用的简易工具封装""" + + def __init__(self, name: str, description: str, parameters: List[Tuple], execute_func): + self.name = name + self.description = description + self.parameters = parameters + self.execute_func = execute_func + + def get_tool_definition(self) -> Dict[str, Any]: + return { + "name": self.name, + "description": self.description, + "parameters": self.parameters, + } + + async def execute(self, **kwargs) -> str: + return await self.execute_func(**kwargs) + + +class DreamToolRegistry: + def __init__(self) -> None: + self.tools: Dict[str, DreamTool] = {} + + def register_tool(self, tool: DreamTool) -> None: + """ + 注册或更新 dream 工具。 + 注意：dream agent 每个 chat_id 会重新初始化工具，这里允许覆盖已有同名工具。 + """ + self.tools[tool.name] = tool + logger.info(f"注册/更新 dream 工具: {tool.name}") + + def get_tool(self, name: str) -> Optional[DreamTool]: + return self.tools.get(name) + + def get_tool_definitions(self) -> List[Dict[str, Any]]: + return [tool.get_tool_definition() for tool in self.tools.values()] + + +_dream_tool_registry = DreamToolRegistry() + + +def get_dream_tool_registry() -> DreamToolRegistry: + return _dream_tool_registry + + +def init_dream_tools(chat_id: str) -> None: + """注册 dream agent 可用的 ChatHistory / Jargon 相关工具（限定在当前 chat_id 作用域内）""" + from src.llm_models.payload_content.tool_option import ToolParamType + + # 通过工厂函数生成绑定当前 chat_id 的工具实现 + search_chat_history = make_search_chat_history(chat_id) + get_chat_history_detail = make_get_chat_history_detail(chat_id) + delete_chat_history = make_delete_chat_history(chat_id) + create_chat_history = make_create_chat_history(chat_id) + update_chat_history = make_update_chat_history(chat_id) + finish_maintenance = make_finish_maintenance(chat_id) + + search_jargon = make_search_jargon(chat_id) + delete_jargon = make_delete_jargon(chat_id) + update_jargon = make_update_jargon(chat_id) + + _dream_tool_registry.register_tool( + DreamTool( + "search_chat_history", + "根据关键词或参与人查询当前 chat_id 下的 ChatHistory 概览，便于快速定位相关记忆。", + [ + ( + "keyword", + ToolParamType.STRING, + "关键词（可选，支持多个关键词，可用空格、逗号等分隔）。", + False, + None, + ), + ("participant", ToolParamType.STRING, "参与人昵称（可选）。", False, None), + ], + search_chat_history, + ) + ) + + _dream_tool_registry.register_tool( + DreamTool( + "get_chat_history_detail", + "根据 memory_id 获取单条 ChatHistory 的详细内容，包含主题、概括、关键词、关键信息等字段（不包含原文）。", + [ + ("memory_id", ToolParamType.INTEGER, "ChatHistory 主键 ID。", True, None), + ], + get_chat_history_detail, + ) + ) + + _dream_tool_registry.register_tool( + DreamTool( + "delete_chat_history", + "根据 memory_id 删除一条 ChatHistory 记录（请谨慎使用）。", + [ + ("memory_id", ToolParamType.INTEGER, "需要删除的 ChatHistory 主键 ID。", True, None), + ], + delete_chat_history, + ) + ) + + _dream_tool_registry.register_tool( + DreamTool( + "update_chat_history", + "按字段更新 ChatHistory 记录，可用于清理、重写或补充信息。", + [ + ("memory_id", ToolParamType.INTEGER, "需要更新的 ChatHistory 主键 ID。", True, None), + ("theme", ToolParamType.STRING, "新的主题标题，如果不需要修改可不填。", False, None), + ("summary", ToolParamType.STRING, "新的概括内容，如果不需要修改可不填。", False, None), + ("keywords", ToolParamType.STRING, "新的关键词 JSON 字符串，如 ['关键词1','关键词2']。", False, None), + ("key_point", ToolParamType.STRING, "新的关键信息 JSON 字符串，如 ['要点1','要点2']。", False, None), + ], + update_chat_history, + ) + ) + + _dream_tool_registry.register_tool( + DreamTool( + "create_chat_history", + "根据整理后的理解创建一条新的 ChatHistory 概括记录（主题、概括、关键词、关键信息等）。", + [ + ("theme", ToolParamType.STRING, "新的主题标题（必填）。", True, None), + ("summary", ToolParamType.STRING, "新的概括内容（必填）。", True, None), + ( + "keywords", + ToolParamType.STRING, + "新的关键词 JSON 字符串，如 ['关键词1','关键词2']（必填）。", + True, + None, + ), + ( + "key_point", + ToolParamType.STRING, + "新的关键信息 JSON 字符串，如 ['要点1','要点2']（必填）。", + True, + None, + ), + ("start_time", ToolParamType.STRING, "起始时间戳（秒，Unix 时间，必填）。", True, None), + ("end_time", ToolParamType.STRING, "结束时间戳（秒，Unix 时间，必填）。", True, None), + ], + create_chat_history, + ) + ) + + _dream_tool_registry.register_tool( + DreamTool( + "finish_maintenance", + "结束本次 dream 维护任务。当你认为当前 chat_id 下的维护工作已经完成，没有更多需要整理、合并或修改的内容时，调用此工具来主动结束本次运行。", + [ + ( + "reason", + ToolParamType.STRING, + "结束维护的原因说明（可选），例如 '已完成所有记录的整理' 或 '当前记录质量良好，无需进一步维护'。", + False, + None, + ), + ], + finish_maintenance, + ) + ) + + # ==================== Jargon 维护工具 ==================== + # 注册 Jargon 工具 + _dream_tool_registry.register_tool( + DreamTool( + "search_jargon", + "根据一个或多个关键词搜索当前 chat_id 相关的 Jargon 记录概览（只包含 is_jargon=True，含全局 Jargon），便于快速理解黑话库。", + [ + ("keyword", ToolParamType.STRING, "按一个或多个关键词搜索内容/含义/推断结果（必填）。", True, None), + ], + search_jargon, + ) + ) + + +async def run_dream_agent_once( + chat_id: str, + max_iterations: Optional[int] = None, + start_memory_id: Optional[int] = None, +) -> None: + """ + 运行一次 dream agent，对指定 chat_id 的 ChatHistory 进行最多 max_iterations 轮的整理。 + 如果 max_iterations 为 None，则使用配置文件中的默认值。 + """ + if max_iterations is None: + max_iterations = global_config.dream.max_iterations + + start_ts = time.time() + logger.info(f"[dream] 开始对 chat_id={chat_id} 进行 dream 维护，最多迭代 {max_iterations} 轮") + + # 初始化工具（作用域限定在当前 chat_id） + init_dream_tools(chat_id) + + tool_registry = get_dream_tool_registry() + tool_defs = tool_registry.get_tool_definitions() + + bot_name = global_config.bot.nickname + time_now = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) + + head_prompt = await global_prompt_manager.format_prompt( + "dream_react_head_prompt", + bot_name=bot_name, + time_now=time_now, + chat_id=chat_id, + start_memory_id=start_memory_id if start_memory_id is not None else "无（本轮由你自由选择切入点）", + max_iterations=max_iterations, + ) + + conversation_messages: List[Message] = [] + + # 如果提供了起始记忆 ID，则在对话正式开始前，先把这条记忆的详细信息放入上下文， + # 避免 LLM 还需要额外调用一次 get_chat_history_detail 才能看到起始记忆内容。 + if start_memory_id is not None: + try: + record = ChatHistory.get_or_none(ChatHistory.id == start_memory_id) + if record: + start_time_str = ( + time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(record.start_time)) + if record.start_time + else "未知" + ) + end_time_str = ( + time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(record.end_time)) if record.end_time else "未知" + ) + detail_text = ( + f"ID={record.id}\n" + f"chat_id={record.chat_id}\n" + f"时间范围={start_time_str} 至 {end_time_str}\n" + f"主题={record.theme or '无'}\n" + f"关键词={record.keywords or '无'}\n" + f"参与者={record.participants or '无'}\n" + f"概括={record.summary or '无'}\n" + f"关键信息={record.key_point or '无'}" + ) + + logger.debug( + f"[dream] 预加载起始记忆详情 memory_id={start_memory_id}，" + f"预览: {detail_text[:200].replace(chr(10), ' ')}" + ) + + start_detail_builder = MessageBuilder() + start_detail_builder.set_role(RoleType.User) + start_detail_builder.add_text_content( + "【起始记忆详情】以下是本轮随机/指定的起始记忆的详细信息，供你在整理时优先参考：\n\n" + detail_text + ) + conversation_messages.append(start_detail_builder.build()) + else: + logger.warning( + f"[dream] 提供的 start_memory_id={start_memory_id} 未找到对应 ChatHistory 记录，" + "将不预加载起始记忆详情。" + ) + except Exception as e: + logger.error(f"[dream] 预加载起始记忆详情失败 start_memory_id={start_memory_id}: {e}") + + # 注意：message_factory 必须是同步函数，返回消息列表（不能是 async/coroutine） + def message_factory( + _client, + *, + _head_prompt: str = head_prompt, + _conversation_messages: List[Message] = conversation_messages, + ) -> List[Message]: + messages: List[Message] = [] + system_builder = MessageBuilder() + system_builder.set_role(RoleType.System) + system_builder.add_text_content(_head_prompt) + messages.append(system_builder.build()) + messages.extend(_conversation_messages) + return messages + + for iteration in range(1, max_iterations + 1): + # 在每轮开始时，添加轮次信息到对话中 + remaining_rounds = max_iterations - iteration + 1 + round_info_builder = MessageBuilder() + round_info_builder.set_role(RoleType.User) + round_info_builder.add_text_content( + f"【轮次信息】当前是第 {iteration}/{max_iterations} 轮，还剩 {remaining_rounds} 轮。" + ) + conversation_messages.append(round_info_builder.build()) + + # 调用 LLM 让其决定是否要使用工具 + ( + success, + response, + reasoning_content, + model_name, + tool_calls, + ) = await llm_api.generate_with_model_with_tools_by_message_factory( + message_factory, + model_config=model_config.model_task_config.tool_use, + tool_options=tool_defs, + request_type="dream.react", + ) + + if not success: + logger.error(f"[dream] 第 {iteration} 轮 LLM 调用失败: {response}") + break + + # 先输出「思考」内容，再输出工具调用信息（思考文本较长，仅在 debug 下输出） + thought_log = reasoning_content or (response[:300] if response else "") + if thought_log: + logger.debug(f"[dream] 第 {iteration} 轮思考内容: {thought_log}") + + logger.info( + f"[dream] 第 {iteration} 轮响应，模型={model_name}，工具调用数={len(tool_calls) if tool_calls else 0}" + ) + + assistant_msg: Optional[Message] = None + if tool_calls: + builder = MessageBuilder() + builder.set_role(RoleType.Assistant) + if response and response.strip(): + builder.add_text_content(response) + builder.set_tool_calls(tool_calls) + assistant_msg = builder.build() + elif response and response.strip(): + builder = MessageBuilder() + builder.set_role(RoleType.Assistant) + builder.add_text_content(response) + assistant_msg = builder.build() + + if assistant_msg: + conversation_messages.append(assistant_msg) + + # 如果本轮没有工具调用，仅作为思考记录，继续下一轮 + if not tool_calls: + logger.debug(f"[dream] 第 {iteration} 轮未调用任何工具，仅记录思考。") + continue + + # 执行所有工具调用 + tasks = [] + finish_maintenance_called = False + for tc in tool_calls: + tool = tool_registry.get_tool(tc.func_name) + if not tool: + logger.warning(f"[dream] 未知工具：{tc.func_name}") + continue + + # 检测是否调用了 finish_maintenance 工具 + if tc.func_name == "finish_maintenance": + finish_maintenance_called = True + + params = tc.args or {} + + async def _run_single(t: DreamTool, p: Dict[str, Any], call_id: str, it: int): + try: + result = await t.execute(**p) + logger.debug(f"[dream] 第 {it} 轮 工具 {t.name} 执行完成") + return call_id, result + except Exception as e: + logger.error(f"[dream] 工具 {t.name} 执行失败: {e}") + return call_id, f"工具 {t.name} 执行失败: {e}" + + tasks.append(_run_single(tool, params, tc.call_id, iteration)) + + if not tasks: + continue + + tool_results = await asyncio.gather(*tasks, return_exceptions=False) + + # 将工具结果作为 Tool 消息追加 + for call_id, obs in tool_results: + tool_builder = MessageBuilder() + tool_builder.set_role(RoleType.Tool) + tool_builder.add_text_content(str(obs)) + tool_builder.add_tool_call(call_id) + conversation_messages.append(tool_builder.build()) + + # 如果调用了 finish_maintenance 工具，提前结束本次运行 + if finish_maintenance_called: + logger.info(f"[dream] 第 {iteration} 轮检测到 finish_maintenance 工具调用，提前结束本次维护。") + break + + cost = time.time() - start_ts + logger.info(f"[dream] 对 chat_id={chat_id} 的 dream 维护结束，共迭代 {iteration} 轮，耗时 {cost:.1f} 秒") + + # 生成梦境总结 + await generate_dream_summary(chat_id, conversation_messages, iteration, cost) + + +def _pick_random_chat_id() -> Optional[str]: + """从 ChatHistory 中随机选择一个 chat_id，用于 dream agent 本次维护 + + 规则： + - 只在 chat_id 所属的 ChatHistory 记录数 >= 10 时才会参与随机选择； + - 记录数不足 10 的 chat_id 将被跳过，不会触发做梦 react。 + """ + try: + # 统计每个 chat_id 的记录数，只保留记录数 >= 10 的 chat_id + rows = ( + ChatHistory.select(ChatHistory.chat_id, fn.COUNT(ChatHistory.id).alias("cnt")) + .group_by(ChatHistory.chat_id) + .having(fn.COUNT(ChatHistory.id) >= 10) + .order_by(ChatHistory.chat_id) + .limit(200) + ) + eligible_ids = [r.chat_id for r in rows] + if not eligible_ids: + logger.warning("[dream] ChatHistory 中暂无满足条件（记录数 >= 10）的 chat_id，本轮 dream 任务跳过。") + return None + chosen = random.choice(eligible_ids) + logger.info(f"[dream] 从 {len(eligible_ids)} 个满足条件的 chat_id 中随机选择：{chosen}") + return chosen + except Exception as e: + logger.error(f"[dream] 随机选择 chat_id 失败: {e}") + return None + + +def _pick_random_memory_for_chat(chat_id: str) -> Optional[int]: + """ + 在给定 chat_id 下随机选择一条 ChatHistory 记录，作为本轮整理的起始记忆。 + """ + try: + rows = ( + ChatHistory.select(ChatHistory.id) + .where(ChatHistory.chat_id == chat_id) + .order_by(ChatHistory.start_time.asc()) + .limit(200) + ) + ids = [r.id for r in rows] + if not ids: + logger.warning(f"[dream] chat_id={chat_id} 下暂无 ChatHistory 记录，无法选择起始记忆。") + return None + return random.choice(ids) + except Exception as e: + logger.error(f"[dream] 在 chat_id={chat_id} 下随机选择起始记忆失败: {e}") + return None + + +async def run_dream_cycle_once() -> None: + """ + 单次 dream 周期： + - 随机选择一个 chat_id + - 在该 chat_id 下随机选择一条 ChatHistory 作为起始记忆 + - 以这条起始记忆为切入点，对该 chat_id 运行一次 dream agent（最多 15 轮） + """ + chat_id = _pick_random_chat_id() + if not chat_id: + return + + start_memory_id = _pick_random_memory_for_chat(chat_id) + await run_dream_agent_once( + chat_id=chat_id, + max_iterations=None, # 使用配置文件中的默认值 + start_memory_id=start_memory_id, + ) + + +async def start_dream_scheduler( + first_delay_seconds: Optional[int] = None, + interval_seconds: Optional[int] = None, + stop_event: Optional[asyncio.Event] = None, +) -> None: + """ + dream 调度器： + - 程序启动后先等待 first_delay_seconds（如果为 None，则使用配置文件中的值，默认 60s） + - 然后每隔 interval_seconds（如果为 None，则使用配置文件中的值，默认 30 分钟）运行一次 dream agent 周期 + - 如果提供 stop_event，则在 stop_event 被 set() 后优雅退出循环 + """ + if first_delay_seconds is None: + first_delay_seconds = global_config.dream.first_delay_seconds + + if interval_seconds is None: + interval_seconds = global_config.dream.interval_minutes * 60 + + logger.info( + f"[dream] dream 调度器启动：首次延迟 {first_delay_seconds}s，之后每隔 {interval_seconds}s ({interval_seconds // 60} 分钟) 运行一次 dream agent" + ) + + try: + await asyncio.sleep(first_delay_seconds) + while True: + if stop_event is not None and stop_event.is_set(): + logger.info("[dream] 收到停止事件，结束 dream 调度器循环。") + break + + start_ts = time.time() + # 检查当前时间是否在允许做梦的时间段内 + if not global_config.dream.is_in_dream_time(): + logger.debug("[dream] 当前时间不在允许做梦的时间段内，跳过本次执行") + else: + try: + await run_dream_cycle_once() + except Exception as e: + logger.error(f"[dream] 单次 dream 周期执行异常: {e}") + + elapsed = time.time() - start_ts + # 保证两次执行之间至少间隔 interval_seconds + to_sleep = max(0.0, interval_seconds - elapsed) + await asyncio.sleep(to_sleep) + except asyncio.CancelledError: + logger.info("[dream] dream 调度器任务被取消，准备退出。") + raise + + +# 初始化提示词 +init_dream_prompts() diff --git a/src/dream/dream_generator.py b/src/dream/dream_generator.py new file mode 100644 index 00000000..8c4b5bc3 --- /dev/null +++ b/src/dream/dream_generator.py @@ -0,0 +1,251 @@ +import random +from typing import List, Optional + +from src.common.logger import get_logger +from src.config.config import global_config, model_config +from src.chat.utils.prompt_builder import Prompt +from src.llm_models.payload_content.message import RoleType, Message +from src.llm_models.utils_model import LLMRequest +from src.chat.message_receive.chat_stream import get_chat_manager +from src.plugin_system.apis import send_api + +logger = get_logger("dream_generator") + +# 初始化 utils 模型用于生成梦境总结 +_dream_summary_model: Optional[LLMRequest] = None + +# 梦境风格列表（21种） +DREAM_STYLES = [ + "保持诗意和想象力，自由编写", + "诗意朦胧，如薄雾笼罩的清晨", + "奇幻冒险，充满未知与探索", + "温暖怀旧，带着时光的痕迹", + "神秘悬疑，暗藏深意", + "浪漫唯美，如诗如画", + "科幻未来，科技与想象交织", + "自然清新，如山林间的微风", + "深沉哲思，引人深思", + "轻松幽默，充满趣味", + "悲伤忧郁，带着淡淡哀愁", + "激昂热烈，充满活力", + "宁静平和，如湖面般平静", + "荒诞离奇，打破常规", + "细腻温柔，如春风拂面", + "壮阔宏大，气势磅礴", + "简约纯粹，返璞归真", + "复杂多变，层次丰富", + "梦幻迷离，虚实难辨", + "现实写意，贴近生活", + "抽象概念，超越具象", +] + + +def get_random_dream_styles(count: int = 2) -> List[str]: + """从梦境风格列表中随机选择指定数量的风格""" + return random.sample(DREAM_STYLES, min(count, len(DREAM_STYLES))) + + +def get_dream_summary_model() -> LLMRequest: + """获取用于生成梦境总结的 utils 模型实例""" + global _dream_summary_model + if _dream_summary_model is None: + _dream_summary_model = LLMRequest( + model_set=model_config.model_task_config.utils, + request_type="dream.summary", + ) + return _dream_summary_model + + +def init_dream_summary_prompt() -> None: + """初始化梦境总结的提示词""" + Prompt( + """ +你刚刚完成了一次对聊天记录的记忆整理工作。以下是整理过程的摘要： +整理过程： +{conversation_text} + +请将这次整理涉及的相关信息改写为一个富有诗意和想象力的"梦境"，请你仅使用具体的记忆的内容，而不是整理过程编写。 +要求： +1. 使用第一人称视角 +2. 叙述直白，不要复杂修辞，口语化 +3. 长度控制在200-800字 +4. 用中文输出 +梦境风格： +{dream_styles} +请直接输出梦境内容，不要添加其他说明： +""", + name="dream_summary_prompt", + ) + + +async def generate_dream_summary( + chat_id: str, + conversation_messages: List[Message], + total_iterations: int, + time_cost: float, +) -> None: + """生成梦境总结，输出到日志，并根据配置可选地推送给指定用户""" + try: + import json + from src.chat.utils.prompt_builder import global_prompt_manager + + # 第一步：建立工具调用结果映射 (call_id -> result) + tool_results_map: dict[str, str] = {} + for msg in conversation_messages: + if msg.role == RoleType.Tool and msg.tool_call_id: + content = "" + if msg.content: + if isinstance(msg.content, list) and msg.content: + content = msg.content[0].text if hasattr(msg.content[0], "text") else str(msg.content[0]) + else: + content = str(msg.content) + tool_results_map[msg.tool_call_id] = content + + # 第二步：详细记录所有工具调用操作和结果到日志 + tool_call_count = 0 + logger.info(f"[dream][工具调用详情] 开始记录 chat_id={chat_id} 的所有工具调用操作：") + + for msg in conversation_messages: + if msg.role == RoleType.Assistant and msg.tool_calls: + tool_call_count += 1 + # 提取思考内容 + thought_content = "" + if msg.content: + if isinstance(msg.content, list) and msg.content: + thought_content = ( + msg.content[0].text if hasattr(msg.content[0], "text") else str(msg.content[0]) + ) + else: + thought_content = str(msg.content) + + logger.info(f"[dream][工具调用详情] === 第 {tool_call_count} 组工具调用 ===") + if thought_content: + logger.info( + f"[dream][工具调用详情] 思考内容：{thought_content[:500]}{'...' if len(thought_content) > 500 else ''}" + ) + + # 记录每个工具调用的详细信息 + for idx, tool_call in enumerate(msg.tool_calls, 1): + tool_name = tool_call.func_name + tool_args = tool_call.args or {} + tool_call_id = tool_call.call_id + tool_result = tool_results_map.get(tool_call_id, "未找到执行结果") + + # 格式化参数 + try: + args_str = json.dumps(tool_args, ensure_ascii=False, indent=2) if tool_args else "无参数" + except Exception: + args_str = str(tool_args) + + logger.info(f"[dream][工具调用详情] --- 工具 {idx}: {tool_name} ---") + logger.info(f"[dream][工具调用详情] 调用参数：\n{args_str}") + logger.info(f"[dream][工具调用详情] 执行结果：\n{tool_result}") + logger.info(f"[dream][工具调用详情] {'-' * 60}") + + logger.info(f"[dream][工具调用详情] 共记录了 {tool_call_count} 组工具调用操作") + + # 第三步：构建对话历史摘要（用于生成梦境） + conversation_summary = [] + for msg in conversation_messages: + role = msg.role.value if hasattr(msg.role, "value") else str(msg.role) + content = "" + if msg.content: + content = msg.content[0].text if isinstance(msg.content, list) and msg.content else str(msg.content) + + if role == "user" and "轮次信息" in content: + # 跳过轮次信息消息 + continue + + if role == "assistant": + # 只保留思考内容，简化工具调用信息 + if content: + # 截取前500字符，避免过长 + content_preview = content[:500] + ("..." if len(content) > 500 else "") + conversation_summary.append(f"[{role}] {content_preview}") + elif role == "tool": + # 工具结果，只保留关键信息 + if content: + # 截取前300字符 + content_preview = content[:300] + ("..." if len(content) > 300 else "") + conversation_summary.append(f"[工具执行] {content_preview}") + + conversation_text = "\n".join(conversation_summary[-20:]) # 只保留最后20条消息 + + # 随机选择2个梦境风格 + selected_styles = get_random_dream_styles(2) + dream_styles_text = "\n".join([f"{i + 1}. {style}" for i, style in enumerate(selected_styles)]) + + # 使用 Prompt 管理器格式化梦境生成 prompt + dream_prompt = await global_prompt_manager.format_prompt( + "dream_summary_prompt", + chat_id=chat_id, + total_iterations=total_iterations, + time_cost=time_cost, + conversation_text=conversation_text, + dream_styles=dream_styles_text, + ) + + # 调用 utils 模型生成梦境 + summary_model = get_dream_summary_model() + dream_content, (reasoning, model_name, _) = await summary_model.generate_response_async( + dream_prompt, + max_tokens=512, + temperature=0.8, + ) + + if dream_content: + logger.info(f"[dream][梦境总结] 对 chat_id={chat_id} 的整理过程梦境：\n{dream_content}") + + # 第五步：根据配置决定是否将梦境发送给指定用户 + try: + dream_send_raw = getattr(global_config.dream, "dream_send", "") or "" + dream_send = dream_send_raw.strip() + if dream_send: + parts = dream_send.split(":") + if len(parts) != 2: + logger.warning( + f"[dream][梦境总结] dream_send 配置格式不正确，应为 'platform:user_id'，当前值: {dream_send_raw!r}" + ) + else: + platform, user_id = parts[0].strip(), parts[1].strip() + if not platform or not user_id: + logger.warning( + f"[dream][梦境总结] dream_send 平台或用户ID为空，当前值: {dream_send_raw!r}" + ) + else: + # 默认为私聊会话 + stream_id = get_chat_manager().get_stream_id( + platform=platform, + id=str(user_id), + is_group=False, + ) + if not stream_id: + logger.error( + f"[dream][梦境总结] 无法根据 dream_send 找到有效的聊天流，" + f"platform={platform!r}, user_id={user_id!r}" + ) + else: + ok = await send_api.text_to_stream( + dream_content, + stream_id=stream_id, + typing=False, + storage_message=True, + ) + if ok: + logger.info( + f"[dream][梦境总结] 已将梦境结果发送给配置的目标用户: {platform}:{user_id}" + ) + else: + logger.error( + f"[dream][梦境总结] 向 {platform}:{user_id} 发送梦境结果失败" + ) + except Exception as send_exc: + logger.error(f"[dream][梦境总结] 发送梦境结果到配置用户时出错: {send_exc}", exc_info=True) + else: + logger.warning("[dream][梦境总结] 未能生成梦境总结") + + except Exception as e: + logger.error(f"[dream][梦境总结] 生成梦境总结失败: {e}", exc_info=True) + + +init_dream_summary_prompt() diff --git a/src/dream/tools/__init__.py b/src/dream/tools/__init__.py new file mode 100644 index 00000000..da5c237e --- /dev/null +++ b/src/dream/tools/__init__.py @@ -0,0 +1,7 @@ +""" +dream agent 工具实现模块。 + +每个工具的具体实现放在独立文件中，通过 make_xxx(chat_id) 工厂函数 +生成绑定到特定 chat_id 的协程函数，由 dream_agent.init_dream_tools 统一注册。 +""" + diff --git a/src/dream/tools/create_chat_history_tool.py b/src/dream/tools/create_chat_history_tool.py new file mode 100644 index 00000000..ccf27e4e --- /dev/null +++ b/src/dream/tools/create_chat_history_tool.py @@ -0,0 +1,63 @@ +import time + +from src.common.logger import get_logger +from src.common.database.database_model import ChatHistory + +logger = get_logger("dream_agent") + + +def make_create_chat_history(chat_id: str): + async def create_chat_history( + theme: str, + summary: str, + keywords: str, + key_point: str, + start_time: float, + end_time: float, + ) -> str: + """创建一条新的 ChatHistory 概括记录（用于整理/合并后的新记忆）""" + try: + logger.info( + f"[dream][tool] 调用 create_chat_history(" + f"theme={bool(theme)}, summary={bool(summary)}, " + f"keywords={bool(keywords)}, key_point={bool(key_point)}, " + f"start_time={start_time}, end_time={end_time}) (chat_id={chat_id})" + ) + + now_ts = time.time() + + # 将传入的 start_time/end_time（如果有）解析为时间戳；否则回退为当前时间 + def _parse_ts(value, default): + if value is None: + return default + try: + return float(value) + except (TypeError, ValueError): + return default + + start_ts = _parse_ts(start_time, now_ts) + end_ts = _parse_ts(end_time, now_ts) + + record = ChatHistory.create( + chat_id=chat_id, + theme=theme, + summary=summary, + keywords=keywords, + key_point=key_point, + # 对于由 dream 整理产生的新概括，时间范围优先使用工具提供的时间，否则使用当前时间占位 + start_time=start_ts, + end_time=end_ts, + ) + + msg = ( + f"已创建新的 ChatHistory 记录，ID={record.id}，" + f"theme={record.theme or '无'}，summary={'有' if record.summary else '无'}。" + ) + logger.info(f"[dream][tool] create_chat_history 完成: {msg}") + return msg + except Exception as e: + logger.error(f"create_chat_history 失败: {e}") + return f"create_chat_history 执行失败: {e}" + + return create_chat_history + diff --git a/src/dream/tools/delete_chat_history_tool.py b/src/dream/tools/delete_chat_history_tool.py new file mode 100644 index 00000000..6a14d57f --- /dev/null +++ b/src/dream/tools/delete_chat_history_tool.py @@ -0,0 +1,26 @@ +from src.common.logger import get_logger +from src.common.database.database_model import ChatHistory + +logger = get_logger("dream_agent") + + +def make_delete_chat_history(chat_id: str): # chat_id 目前未直接使用，预留以备扩展 + async def delete_chat_history(memory_id: int) -> str: + """删除一条 chat_history 记录""" + try: + logger.info(f"[dream][tool] 调用 delete_chat_history(memory_id={memory_id})") + record = ChatHistory.get_or_none(ChatHistory.id == memory_id) + if not record: + msg = f"未找到 ID={memory_id} 的 ChatHistory 记录，无法删除。" + logger.info(f"[dream][tool] delete_chat_history 未找到记录: {msg}") + return msg + rows = ChatHistory.delete().where(ChatHistory.id == memory_id).execute() + msg = f"已删除 ID={memory_id} 的 ChatHistory 记录，受影响行数={rows}。" + logger.info(f"[dream][tool] delete_chat_history 完成: {msg}") + return msg + except Exception as e: + logger.error(f"delete_chat_history 失败: {e}") + return f"delete_chat_history 执行失败: {e}" + + return delete_chat_history + diff --git a/src/dream/tools/delete_jargon_tool.py b/src/dream/tools/delete_jargon_tool.py new file mode 100644 index 00000000..cfab51aa --- /dev/null +++ b/src/dream/tools/delete_jargon_tool.py @@ -0,0 +1,26 @@ +from src.common.logger import get_logger +from src.common.database.database_model import Jargon + +logger = get_logger("dream_agent") + + +def make_delete_jargon(chat_id: str): # chat_id 目前未直接使用，预留以备扩展 + async def delete_jargon(jargon_id: int) -> str: + """删除一条 Jargon 记录""" + try: + logger.info(f"[dream][tool] 调用 delete_jargon(jargon_id={jargon_id})") + record = Jargon.get_or_none(Jargon.id == jargon_id) + if not record: + msg = f"未找到 ID={jargon_id} 的 Jargon 记录，无法删除。" + logger.info(f"[dream][tool] delete_jargon 未找到记录: {msg}") + return msg + rows = Jargon.delete().where(Jargon.id == jargon_id).execute() + msg = f"已删除 ID={jargon_id} 的 Jargon 记录（内容：{record.content}），受影响行数={rows}。" + logger.info(f"[dream][tool] delete_jargon 完成: {msg}") + return msg + except Exception as e: + logger.error(f"delete_jargon 失败: {e}") + return f"delete_jargon 执行失败: {e}" + + return delete_jargon + diff --git a/src/dream/tools/finish_maintenance_tool.py b/src/dream/tools/finish_maintenance_tool.py new file mode 100644 index 00000000..c2dda545 --- /dev/null +++ b/src/dream/tools/finish_maintenance_tool.py @@ -0,0 +1,17 @@ +from typing import Optional + +from src.common.logger import get_logger + +logger = get_logger("dream_agent") + + +def make_finish_maintenance(chat_id: str): # chat_id 目前未直接使用，预留以备扩展 + async def finish_maintenance(reason: Optional[str] = None) -> str: + """结束本次 dream 维护任务。当你认为当前 chat_id 下的维护工作已经完成，没有更多需要整理的内容时，调用此工具来结束本次运行。""" + reason_text = f"，原因：{reason}" if reason else "" + msg = f"DREAM_MAINTENANCE_COMPLETE{reason_text}" + logger.info(f"[dream][tool] 调用 finish_maintenance，结束本次维护{reason_text}") + return msg + + return finish_maintenance + diff --git a/src/dream/tools/get_chat_history_detail_tool.py b/src/dream/tools/get_chat_history_detail_tool.py new file mode 100644 index 00000000..47c427d0 --- /dev/null +++ b/src/dream/tools/get_chat_history_detail_tool.py @@ -0,0 +1,45 @@ +import time + +from src.common.logger import get_logger +from src.common.database.database_model import ChatHistory + +logger = get_logger("dream_agent") + + +def make_get_chat_history_detail(chat_id: str): # chat_id 目前未直接使用，预留以备扩展 + async def get_chat_history_detail(memory_id: int) -> str: + """获取单条 chat_history 的完整内容""" + try: + logger.info(f"[dream][tool] 调用 get_chat_history_detail(memory_id={memory_id})") + record = ChatHistory.get_or_none(ChatHistory.id == memory_id) + if not record: + msg = f"未找到 ID={memory_id} 的 ChatHistory 记录。" + logger.info(f"[dream][tool] get_chat_history_detail 未找到记录: {msg}") + return msg + + # 将时间戳转换为可读时间格式 + start_time_str = ( + time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(record.start_time)) if record.start_time else "未知" + ) + end_time_str = ( + time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(record.end_time)) if record.end_time else "未知" + ) + + result = ( + f"ID={record.id}\n" + # f"chat_id={record.chat_id}\n" + f"时间范围={start_time_str} 至 {end_time_str}\n" + f"主题={record.theme or '无'}\n" + f"关键词={record.keywords or '无'}\n" + f"参与者={record.participants or '无'}\n" + f"概括={record.summary or '无'}\n" + f"关键信息={record.key_point or '无'}" + ) + logger.debug(f"[dream][tool] get_chat_history_detail 成功，预览: {result[:200].replace(chr(10), ' ')}") + return result + except Exception as e: + logger.error(f"get_chat_history_detail 失败: {e}") + return f"get_chat_history_detail 执行失败: {e}" + + return get_chat_history_detail + diff --git a/src/dream/tools/search_chat_history_tool.py b/src/dream/tools/search_chat_history_tool.py new file mode 100644 index 00000000..1de0f253 --- /dev/null +++ b/src/dream/tools/search_chat_history_tool.py @@ -0,0 +1,215 @@ +import json +from typing import List, Optional + +from src.common.logger import get_logger +from src.common.database.database_model import ChatHistory +from src.chat.utils.utils import parse_keywords_string + +logger = get_logger("dream_agent") + + +def make_search_chat_history(chat_id: str): + async def search_chat_history( + keyword: Optional[str] = None, + participant: Optional[str] = None, + ) -> str: + """根据关键词或参与人查询记忆，返回匹配的记忆id、记忆标题theme和关键词keywords（dream 维护专用版本）""" + try: + # 检查参数 + if not keyword and not participant: + return "未指定查询参数（需要提供keyword或participant之一）" + + logger.info( + f"[dream][tool] 调用 search_chat_history(keyword={keyword}, participant={participant}) " + f"(作用域 chat_id={chat_id})" + ) + + # 构建查询条件 + query = ChatHistory.select().where(ChatHistory.chat_id == chat_id) + + # 执行查询（按时间倒序，最近的在前） + records = list(query.order_by(ChatHistory.start_time.desc()).limit(50)) + + filtered_records: List[ChatHistory] = [] + + for record in records: + participant_matched = True # 如果没有participant条件，默认为True + keyword_matched = True # 如果没有keyword条件，默认为True + + # 检查参与人匹配 + if participant: + participant_matched = False + participants_list: List[str] = [] + if record.participants: + try: + participants_data = ( + json.loads(record.participants) + if isinstance(record.participants, str) + else record.participants + ) + if isinstance(participants_data, list): + participants_list = [str(p).lower() for p in participants_data] + except (json.JSONDecodeError, TypeError, ValueError): + pass + + participant_lower = participant.lower().strip() + if participant_lower and any(participant_lower in p for p in participants_list): + participant_matched = True + + # 检查关键词匹配 + if keyword: + keyword_matched = False + # 解析多个关键词（支持空格、逗号等分隔符） + keywords_list = parse_keywords_string(keyword) + if not keywords_list: + keywords_list = [keyword.strip()] if keyword.strip() else [] + + # 转换为小写以便匹配 + keywords_lower = [kw.lower() for kw in keywords_list if kw.strip()] + + if keywords_lower: + # 在theme、keywords、summary、original_text中搜索 + theme = (record.theme or "").lower() + summary = (record.summary or "").lower() + original_text = (record.original_text or "").lower() + + # 解析record中的keywords JSON + record_keywords_list: List[str] = [] + if record.keywords: + try: + keywords_data = ( + json.loads(record.keywords) if isinstance(record.keywords, str) else record.keywords + ) + if isinstance(keywords_data, list): + record_keywords_list = [str(k).lower() for k in keywords_data] + except (json.JSONDecodeError, TypeError, ValueError): + pass + + # 有容错的全匹配：如果关键词数量>2，允许n-1个关键词匹配；否则必须全部匹配 + matched_count = 0 + for kw in keywords_lower: + kw_matched = ( + kw in theme + or kw in summary + or kw in original_text + or any(kw in k for k in record_keywords_list) + ) + if kw_matched: + matched_count += 1 + + # 计算需要匹配的关键词数量 + total_keywords = len(keywords_lower) + if total_keywords > 2: + # 关键词数量>2，允许n-1个关键词匹配 + required_matches = total_keywords - 1 + else: + # 关键词数量<=2，必须全部匹配 + required_matches = total_keywords + + keyword_matched = matched_count >= required_matches + + # 两者都匹配（如果同时有participant和keyword，需要两者都匹配；如果只有一个条件，只需要该条件匹配） + matched = participant_matched and keyword_matched + + if matched: + filtered_records.append(record) + + if not filtered_records: + if keyword and participant: + keywords_str = "、".join(parse_keywords_string(keyword) if keyword else []) + return f"未找到包含关键词'{keywords_str}'且参与人包含'{participant}'的聊天记录" + elif keyword: + keywords_list = parse_keywords_string(keyword) + keywords_str = "、".join(keywords_list) + if len(keywords_list) > 2: + required_count = len(keywords_list) - 1 + return f"未找到包含至少{required_count}个关键词（共{len(keywords_list)}个）'{keywords_str}'的聊天记录" + else: + return f"未找到包含所有关键词'{keywords_str}'的聊天记录" + elif participant: + return f"未找到参与人包含'{participant}'的聊天记录" + else: + return "未找到相关聊天记录" + + # 如果匹配结果超过20条，不返回具体记录，只返回提示和所有相关关键词 + if len(filtered_records) > 20: + all_keywords_set = set() + for record in filtered_records: + if record.keywords: + try: + keywords_data = ( + json.loads(record.keywords) if isinstance(record.keywords, str) else record.keywords + ) + if isinstance(keywords_data, list): + for k in keywords_data: + k_str = str(k).strip() + if k_str: + all_keywords_set.add(k_str) + except (json.JSONDecodeError, TypeError, ValueError): + continue + + search_label = keyword or participant or "当前条件" + + if all_keywords_set: + keywords_str = "、".join(sorted(all_keywords_set)) + response_text = ( + f"包含“{search_label}”的结果过多，请尝试更多关键词精确查找\n\n" + f'有关"{search_label}"的关键词：\n' + f"{keywords_str}" + ) + else: + response_text = ( + f"包含“{search_label}”的结果过多，请尝试更多关键词精确查找\n\n" + f'有关"{search_label}"的关键词信息为空' + ) + + logger.info( + f"[dream][tool] search_chat_history 匹配结果超过20条，返回关键词汇总提示，总数={len(filtered_records)}" + ) + return response_text + + # 构建结果文本，返回id、theme和keywords（最多20条） + results: List[str] = [] + for record in filtered_records[:20]: + result_parts: List[str] = [] + + # 记忆ID + result_parts.append(f"记忆ID：{record.id}") + + # 主题 + if record.theme: + result_parts.append(f"主题：{record.theme}") + else: + result_parts.append("主题：（无）") + + # 关键词 + if record.keywords: + try: + keywords_data = ( + json.loads(record.keywords) if isinstance(record.keywords, str) else record.keywords + ) + if isinstance(keywords_data, list) and keywords_data: + keywords_str = "、".join([str(k) for k in keywords_data]) + result_parts.append(f"关键词：{keywords_str}") + else: + result_parts.append("关键词：（无）") + except (json.JSONDecodeError, TypeError, ValueError): + result_parts.append("关键词：（无）") + else: + result_parts.append("关键词：（无）") + + results.append("\n".join(result_parts)) + + if not results: + return "未找到相关聊天记录" + + response_text = "\n\n---\n\n".join(results) + + logger.info(f"[dream][tool] search_chat_history 返回 {len(filtered_records)} 条匹配记录") + return response_text + except Exception as e: + logger.error(f"search_chat_history 失败: {e}") + return f"search_chat_history 执行失败: {e}" + + return search_chat_history + diff --git a/src/dream/tools/search_jargon_tool.py b/src/dream/tools/search_jargon_tool.py new file mode 100644 index 00000000..139536ac --- /dev/null +++ b/src/dream/tools/search_jargon_tool.py @@ -0,0 +1,102 @@ +from typing import List + +from src.common.logger import get_logger +from src.common.database.database_model import Jargon +from src.config.config import global_config +from src.chat.utils.utils import parse_keywords_string +from src.bw_learner.learner_utils import parse_chat_id_list, chat_id_list_contains + +logger = get_logger("dream_agent") + + +def make_search_jargon(chat_id: str): + async def search_jargon(keyword: str) -> str: + """根据一个或多个关键词搜索当前 chat_id 相关的 Jargon 记录概览（只包含 is_jargon=True，是否跨 chat_id 由 all_global 决定）""" + try: + if not keyword or not keyword.strip(): + return "未指定查询关键词（参数 keyword 为必填，且不能为空）" + + logger.info(f"[dream][tool] 调用 search_jargon(keyword={keyword}) (作用域 chat_id={chat_id})") + + # 基础条件：只查 is_jargon=True 的记录 + query = Jargon.select().where(Jargon.is_jargon) + + # 根据 all_global 配置决定 chat_id 作用域 + if global_config.expression.all_global_jargon: + # 开启全局黑话：只看 is_global=True 的记录，不区分 chat_id + query = query.where(Jargon.is_global) + else: + # 关闭全局黑话：后续在 Python 层按 chat_id 列表过滤（包含 is_global=True） + pass + + # 先按使用次数排序取一批候选，做一个安全上限 + query = query.order_by(Jargon.count.desc()).limit(200) + candidates = list(query) + + if not candidates: + msg = "未找到符合条件的 Jargon 记录。" + logger.info(f"[dream][tool] search_jargon 无记录: {msg}") + return msg + + # 关键词为必填，因此此处必然执行关键词过滤（支持多个关键词，大小写不敏感） + keywords_list = parse_keywords_string(keyword) or [] + if not keywords_list and keyword.strip(): + keywords_list = [keyword.strip()] + keywords_lower = [kw.lower() for kw in keywords_list if kw.strip()] + + # 先按关键词过滤（仅对 content 字段进行匹配） + filtered_keyword: List[Jargon] = [] + for r in candidates: + content = (r.content or "").lower() + + # 只要命中任意一个关键词即可视为匹配（OR 逻辑） + any_matched = False + for kw in keywords_lower: + if not kw: + continue + if kw in content: + any_matched = True + break + + if any_matched: + filtered_keyword.append(r) + + if global_config.expression.all_global_jargon: + # 全局黑话模式：不再做 chat_id 过滤，直接使用关键词过滤结果 + records = filtered_keyword + else: + # 非全局模式：仅保留全局黑话或 chat_id 列表中包含当前 chat_id 的记录 + records = [] + for r in filtered_keyword: + if r.is_global: + records.append(r) + continue + chat_id_list = parse_chat_id_list(r.chat_id) + if chat_id_list_contains(chat_id_list, chat_id): + records.append(r) + + if not records: + scope_note = ( + "（当前为全局黑话模式，仅统计 is_global=True 的条目）" + if global_config.expression.all_global_jargon + else "（当前为按 chat_id 作用域模式，仅统计全局黑话或与当前 chat_id 相关的条目）" + ) + return f"未找到包含关键词'{keyword}'的 Jargon 记录{scope_note}" + + lines: List[str] = [] + for r in records: + is_jargon_str = "是" if r.is_jargon else "否" if r.is_jargon is False else "未判定" + is_global_str = "全局" if r.is_global else "非全局" + lines.append( + f"ID={r.id} | 内容={r.content} | 含义={r.meaning or '无'} | " + f"chat_id={r.chat_id} | {is_global_str} | 是否黑话={is_jargon_str}" + ) + + result = "\n".join(lines) + logger.info(f"[dream][tool] search_jargon 返回 {len(records)} 条记录") + return result + except Exception as e: + logger.error(f"search_jargon 失败: {e}") + return f"search_jargon 执行失败: {e}" + + return search_jargon diff --git a/src/dream/tools/update_chat_history_tool.py b/src/dream/tools/update_chat_history_tool.py new file mode 100644 index 00000000..c2e92fb9 --- /dev/null +++ b/src/dream/tools/update_chat_history_tool.py @@ -0,0 +1,52 @@ +from typing import Any, Dict, Optional + +from src.common.logger import get_logger +from src.common.database.database_model import ChatHistory +from src.plugin_system.apis import database_api + +logger = get_logger("dream_agent") + + +def make_update_chat_history(chat_id: str): # chat_id 目前未直接使用，预留以备扩展 + async def update_chat_history( + memory_id: int, + theme: Optional[str] = None, + summary: Optional[str] = None, + keywords: Optional[str] = None, + key_point: Optional[str] = None, + ) -> str: + """按字段更新 chat_history（字符串字段要求 JSON 的字段须传入已序列化的字符串）""" + try: + logger.info( + f"[dream][tool] 调用 update_chat_history(memory_id={memory_id}, " + f"theme={bool(theme)}, summary={bool(summary)}, keywords={bool(keywords)}, key_point={bool(key_point)})" + ) + record = ChatHistory.get_or_none(ChatHistory.id == memory_id) + if not record: + msg = f"未找到 ID={memory_id} 的 ChatHistory 记录，无法更新。" + logger.info(f"[dream][tool] update_chat_history 未找到记录: {msg}") + return msg + + data: Dict[str, Any] = {} + if theme is not None: + data["theme"] = theme + if summary is not None: + data["summary"] = summary + if keywords is not None: + data["keywords"] = keywords + if key_point is not None: + data["key_point"] = key_point + + if not data: + return "未提供任何需要更新的字段。" + + await database_api.db_save(ChatHistory, data=data, key_field="id", key_value=memory_id) + msg = f"已更新 ChatHistory 记录 ID={memory_id}，更新字段={list(data.keys())}。" + logger.info(f"[dream][tool] update_chat_history 完成: {msg}") + return msg + except Exception as e: + logger.error(f"update_chat_history 失败: {e}") + return f"update_chat_history 执行失败: {e}" + + return update_chat_history + diff --git a/src/dream/tools/update_jargon_tool.py b/src/dream/tools/update_jargon_tool.py new file mode 100644 index 00000000..59ea1230 --- /dev/null +++ b/src/dream/tools/update_jargon_tool.py @@ -0,0 +1,52 @@ +from typing import Any, Dict, Optional + +from src.common.logger import get_logger +from src.common.database.database_model import Jargon +from src.plugin_system.apis import database_api + +logger = get_logger("dream_agent") + + +def make_update_jargon(chat_id: str): # chat_id 目前未直接使用，预留以备扩展 + async def update_jargon( + jargon_id: int, + meaning: Optional[str] = None, + is_global: Optional[bool] = None, + is_jargon: Optional[bool] = None, + content: Optional[str] = None, + ) -> str: + """按字段更新 Jargon 记录，可用于修正含义、调整全局性、标记是否为黑话等""" + try: + logger.info( + f"[dream][tool] 调用 update_jargon(jargon_id={jargon_id}, " + f"meaning={bool(meaning)}, is_global={is_global}, is_jargon={is_jargon}, content={bool(content)})" + ) + record = Jargon.get_or_none(Jargon.id == jargon_id) + if not record: + msg = f"未找到 ID={jargon_id} 的 Jargon 记录，无法更新。" + logger.info(f"[dream][tool] update_jargon 未找到记录: {msg}") + return msg + + data: Dict[str, Any] = {} + if meaning is not None: + data["meaning"] = meaning + if is_global is not None: + data["is_global"] = is_global + if is_jargon is not None: + data["is_jargon"] = is_jargon + if content is not None: + data["content"] = content + + if not data: + return "未提供任何需要更新的字段。" + + await database_api.db_save(Jargon, data=data, key_field="id", key_value=jargon_id) + msg = f"已更新 Jargon 记录 ID={jargon_id}，更新字段={list(data.keys())}。" + logger.info(f"[dream][tool] update_jargon 完成: {msg}") + return msg + except Exception as e: + logger.error(f"update_jargon 失败: {e}") + return f"update_jargon 执行失败: {e}" + + return update_jargon + diff --git a/src/express/express_utils.py b/src/express/express_utils.py deleted file mode 100644 index 20095561..00000000 --- a/src/express/express_utils.py +++ /dev/null @@ -1,132 +0,0 @@ -import re -import difflib -import random -from datetime import datetime -from typing import Optional, List, Dict - - -def filter_message_content(content: Optional[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 calculate_similarity(text1: str, text2: str) -> float: - """ - 计算两个文本的相似度，返回0-1之间的值 - 使用SequenceMatcher计算相似度 - - Args: - text1: 第一个文本 - text2: 第二个文本 - - Returns: - float: 相似度值，范围0-1 - """ - return difflib.SequenceMatcher(None, text1, text2).ratio() - - -def format_create_date(timestamp: float) -> str: - """ - 将时间戳格式化为可读的日期字符串 - - Args: - timestamp: 时间戳 - - Returns: - str: 格式化后的日期字符串 - """ - try: - return datetime.fromtimestamp(timestamp).strftime("%Y-%m-%d %H:%M:%S") - except (ValueError, OSError): - return "未知时间" - - -def _compute_weights(population: List[Dict]) -> List[float]: - """ - 根据表达的count计算权重，范围限定在1~3之间。 - count越高，权重越高，但最多为基础权重的3倍。 - """ - if not population: - return [] - - counts = [] - for item in population: - count = item.get("count", 1) - try: - count_value = float(count) - except (TypeError, ValueError): - count_value = 1.0 - counts.append(max(count_value, 0.0)) - - min_count = min(counts) - max_count = max(counts) - - if max_count == min_count: - return [1.0 for _ in counts] - - weights = [] - for count_value in counts: - # 线性映射到[1,3]区间 - normalized = (count_value - min_count) / (max_count - min_count) - weights.append(1.0 + normalized * 2.0) # 1~3 - return weights - - -def weighted_sample(population: List[Dict], k: int) -> List[Dict]: - """ - 随机抽样函数 - - Args: - population: 总体数据列表 - k: 需要抽取的数量 - - Returns: - List[Dict]: 抽取的数据列表 - """ - if not population or k <= 0: - return [] - - if len(population) <= k: - return population.copy() - - selected: List[Dict] = [] - population_copy = population.copy() - - for _ in range(min(k, len(population_copy))): - weights = _compute_weights(population_copy) - total_weight = sum(weights) - if total_weight <= 0: - # 回退到均匀随机 - idx = random.randint(0, len(population_copy) - 1) - selected.append(population_copy.pop(idx)) - continue - - threshold = random.uniform(0, total_weight) - cumulative = 0.0 - for idx, weight in enumerate(weights): - cumulative += weight - if threshold <= cumulative: - selected.append(population_copy.pop(idx)) - break - - return selected diff --git a/src/express/expression_learner.py b/src/express/expression_learner.py deleted file mode 100644 index 57c03e77..00000000 --- a/src/express/expression_learner.py +++ /dev/null @@ -1,628 +0,0 @@ -import time -import json -import os -from typing import List, Optional, Tuple -import traceback -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.express_utils import filter_message_content, calculate_similarity -from json_repair import repair_json - - -# MAX_EXPRESSION_COUNT = 300 - -logger = get_logger("expressor") - - -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.summary_model: LLMRequest = LLMRequest( - model_set=model_config.model_task_config.utils_small, request_type="expression.summary" - ) - 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 = 15 / self.learning_intensity # 触发学习所需的最少消息数 - self.min_learning_interval = 120 / 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 表 - for ( - situation, - style, - context, - up_content, - ) in learnt_expressions: - await self._upsert_expression_record( - situation=situation, - style=style, - context=context, - up_content=up_content, - current_time=current_time, - ) - - 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) - expressions = self._filter_self_reference_styles(expressions) - if not expressions: - logger.info("过滤后没有可用的表达方式（style 与机器人名称重复）") - return None - # 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 = 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_self_reference_styles(self, expressions: List[Tuple[str, str]]) -> List[Tuple[str, str]]: - """ - 过滤掉style与机器人名称/昵称重复的表达 - """ - banned_names = set() - bot_nickname = (global_config.bot.nickname or "").strip() - if bot_nickname: - banned_names.add(bot_nickname) - - alias_names = global_config.bot.alias_names or [] - for alias in alias_names: - alias = alias.strip() - if alias: - banned_names.add(alias) - - banned_casefold = {name.casefold() for name in banned_names if name} - - filtered: List[Tuple[str, str]] = [] - removed_count = 0 - for situation, style in expressions: - normalized_style = (style or "").strip() - if normalized_style and normalized_style.casefold() not in banned_casefold: - filtered.append((situation, style)) - else: - removed_count += 1 - - if removed_count: - logger.debug(f"已过滤 {removed_count} 条style与机器人名称重复的表达方式") - - return filtered - - async def _upsert_expression_record( - self, - situation: str, - style: str, - context: str, - up_content: str, - current_time: float, - ) -> None: - expr_obj = Expression.select().where((Expression.chat_id == self.chat_id) & (Expression.style == style)).first() - - if expr_obj: - await self._update_existing_expression( - expr_obj=expr_obj, - situation=situation, - context=context, - up_content=up_content, - current_time=current_time, - ) - return - - await self._create_expression_record( - situation=situation, - style=style, - context=context, - up_content=up_content, - current_time=current_time, - ) - - async def _create_expression_record( - self, - situation: str, - style: str, - context: str, - up_content: str, - current_time: float, - ) -> None: - content_list = [situation] - formatted_situation = await self._compose_situation_text(content_list, 1, situation) - - Expression.create( - situation=formatted_situation, - style=style, - content_list=json.dumps(content_list, ensure_ascii=False), - count=1, - last_active_time=current_time, - chat_id=self.chat_id, - create_date=current_time, - context=context, - up_content=up_content, - ) - - async def _update_existing_expression( - self, - expr_obj: Expression, - situation: str, - context: str, - up_content: str, - current_time: float, - ) -> None: - content_list = self._parse_content_list(expr_obj.content_list) - content_list.append(situation) - - expr_obj.content_list = json.dumps(content_list, ensure_ascii=False) - expr_obj.count = (expr_obj.count or 0) + 1 - expr_obj.last_active_time = current_time - expr_obj.context = context - expr_obj.up_content = up_content - - new_situation = await self._compose_situation_text( - content_list=content_list, - count=expr_obj.count, - fallback=expr_obj.situation, - ) - expr_obj.situation = new_situation - - expr_obj.save() - - def _parse_content_list(self, stored_list: Optional[str]) -> List[str]: - if not stored_list: - return [] - try: - data = json.loads(stored_list) - except json.JSONDecodeError: - return [] - return [str(item) for item in data if isinstance(item, str)] if isinstance(data, list) else [] - - async def _compose_situation_text(self, content_list: List[str], count: int, fallback: str = "") -> str: - sanitized = [c.strip() for c in content_list if c.strip()] - summary = await self._summarize_situations(sanitized) - if summary: - return summary - return "/".join(sanitized) if sanitized else fallback - - async def _summarize_situations(self, situations: List[str]) -> Optional[str]: - if not situations: - return None - - prompt = ( - "请阅读以下多个聊天情境描述，并将它们概括成一句简短的话，" - "长度不超过20个字，保留共同特点：\n" - f"{chr(10).join(f'- {s}' for s in situations[-10:])}\n只输出概括内容。" - ) - - try: - summary, _ = await self.summary_model.generate_response_async(prompt, temperature=0.2) - summary = summary.strip() - if summary: - return summary - except Exception as e: - logger.error(f"概括表达情境失败: {e}") - return None - - 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 = 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/hippo_memorizer/chat_history_summarizer.py b/src/hippo_memorizer/chat_history_summarizer.py new file mode 100644 index 00000000..c8d4a943 --- /dev/null +++ b/src/hippo_memorizer/chat_history_summarizer.py @@ -0,0 +1,1031 @@ +""" +聊天内容概括器 +用于累积、打包和压缩聊天记录 +""" + +import asyncio +import json +import time +import re +import difflib +from pathlib import Path +from typing import Any, Dict, List, Optional, Set +from dataclasses import dataclass, field +from json_repair import repair_json + +from src.common.logger import get_logger +from src.common.data_models.database_data_model import DatabaseMessages +from src.config.config import global_config, model_config +from src.llm_models.utils_model import LLMRequest +from src.plugin_system.apis import message_api +from src.chat.utils.chat_message_builder import build_readable_messages +from src.person_info.person_info import Person +from src.chat.message_receive.chat_stream import get_chat_manager +from src.chat.utils.prompt_builder import Prompt, global_prompt_manager + +logger = get_logger("chat_history_summarizer") + +HIPPO_CACHE_DIR = Path(__file__).resolve().parents[2] / "data" / "hippo_memorizer" + + +def init_prompt(): + """初始化提示词模板""" + + topic_analysis_prompt = """【历史话题标题列表】（仅标题，不含具体内容）： +{history_topics_block} +【历史话题标题列表结束】 + +【本次聊天记录】（每条消息前有编号，用于后续引用）： +{messages_block} +【本次聊天记录结束】 + +请完成以下任务： +**识别话题** +1. 识别【本次聊天记录】中正在进行的一个或多个话题； +2. 【本次聊天记录】的中的消息可能与历史话题有关，也可能毫无关联。 +2. 判断【历史话题标题列表】中的话题是否在【本次聊天记录】中出现，如果出现，则直接使用该历史话题标题字符串； + +**选取消息** +1. 对于每个话题（新话题或历史话题），从上述带编号的消息中选出与该话题强相关的消息编号列表； +2. 每个话题用一句话清晰地描述正在发生的事件，必须包含时间（大致即可）、人物、主要事件和主题，保证精准且有区分度； + +请先输出一段简短思考，说明有什么话题，哪些是不包含在历史话题中的，哪些是包含在历史话题中的，并说明为什么； +然后严格以 JSON 格式输出【本次聊天记录】中涉及的话题，格式如下： +[ + {{ + "topic": "话题", + "message_indices": [1, 2, 5] + }}, + ... +] +""" + Prompt(topic_analysis_prompt, "hippo_topic_analysis_prompt") + + topic_summary_prompt = """ +请基于以下话题，对聊天记录片段进行概括，提取以下信息： + +**话题**：{topic} + +**要求**： +1. 关键词：提取与话题相关的关键词，用列表形式返回（3-10个关键词） +2. 概括：对这段话的平文本概括（50-200字），要求： + - 仔细地转述发生的事件和聊天内容； + - 可以适当摘取聊天记录中的原文； + - 重点突出事件的发展过程和结果； + - 围绕话题这个中心进行概括。 +3. 关键信息：提取话题中的关键信息点，用列表形式返回（3-8个关键信息点），每个关键信息点应该简洁明了。 + +请以JSON格式返回，格式如下： +{{ + "keywords": ["关键词1", "关键词2", ...], + "summary": "概括内容", + "key_point": ["关键信息1", "关键信息2", ...] +}} + +聊天记录： +{original_text} + +请直接返回JSON，不要包含其他内容。 +""" + Prompt(topic_summary_prompt, "hippo_topic_summary_prompt") + + +@dataclass +class MessageBatch: + """消息批次（用于触发话题检查的原始消息累积）""" + + messages: List[DatabaseMessages] + start_time: float + end_time: float + + +@dataclass +class TopicCacheItem: + """ + 话题缓存项 + + Attributes: + topic: 话题标题（一句话描述时间、人物、事件和主题） + messages: 与该话题相关的消息字符串列表（已经通过 build 函数转成可读文本） + participants: 涉及到的发言人昵称集合 + no_update_checks: 连续多少次“检查”没有新增内容 + """ + + topic: str + messages: List[str] = field(default_factory=list) + participants: Set[str] = field(default_factory=set) + no_update_checks: int = 0 + + +class ChatHistorySummarizer: + """聊天内容概括器""" + + def __init__(self, chat_id: str, check_interval: int = 60): + """ + 初始化聊天内容概括器 + + Args: + chat_id: 聊天ID + check_interval: 定期检查间隔（秒），默认60秒 + """ + self.chat_id = chat_id + self._chat_display_name = self._get_chat_display_name() + self.log_prefix = f"[{self._chat_display_name}]" + + # 记录时间点，用于计算新消息 + self.last_check_time = time.time() + + # 记录上一次话题检查的时间，用于判断是否需要触发检查 + self.last_topic_check_time = time.time() + + # 当前累积的消息批次 + self.current_batch: Optional[MessageBatch] = None + + # 话题缓存：topic_str -> TopicCacheItem + # 在内存中维护，并通过本地文件实时持久化 + self.topic_cache: Dict[str, TopicCacheItem] = {} + self._safe_chat_id = self._sanitize_chat_id(self.chat_id) + self._topic_cache_file = HIPPO_CACHE_DIR / f"{self._safe_chat_id}.json" + # 注意：批次加载需要异步查询消息，所以在 start() 中调用 + + # LLM请求器，用于压缩聊天内容 + self.summarizer_llm = LLMRequest( + model_set=model_config.model_task_config.utils, request_type="chat_history_summarizer" + ) + + # 后台循环相关 + self.check_interval = check_interval # 检查间隔（秒） + self._periodic_task: Optional[asyncio.Task] = None + self._running = False + + def _get_chat_display_name(self) -> str: + """获取聊天显示名称""" + try: + chat_name = get_chat_manager().get_stream_name(self.chat_id) + if chat_name: + return chat_name + # 如果获取失败，使用简化的chat_id显示 + if len(self.chat_id) > 20: + return f"{self.chat_id[:8]}..." + return self.chat_id + except Exception: + # 如果获取失败，使用简化的chat_id显示 + if len(self.chat_id) > 20: + return f"{self.chat_id[:8]}..." + return self.chat_id + + def _sanitize_chat_id(self, chat_id: str) -> str: + """用于生成可作为文件名的 chat_id""" + return re.sub(r"[^a-zA-Z0-9_.-]", "_", chat_id) + + def _load_topic_cache_from_disk(self): + """在启动时加载本地话题缓存（同步部分），支持重启后继续""" + try: + if not self._topic_cache_file.exists(): + return + + with self._topic_cache_file.open("r", encoding="utf-8") as f: + data = json.load(f) + + self.last_topic_check_time = data.get("last_topic_check_time", self.last_topic_check_time) + topics_data = data.get("topics", {}) + loaded_count = 0 + for topic, payload in topics_data.items(): + self.topic_cache[topic] = TopicCacheItem( + topic=topic, + messages=payload.get("messages", []), + participants=set(payload.get("participants", [])), + no_update_checks=payload.get("no_update_checks", 0), + ) + loaded_count += 1 + + if loaded_count: + logger.info(f"{self.log_prefix} 已加载 {loaded_count} 个话题缓存，继续追踪") + except Exception as e: + logger.error(f"{self.log_prefix} 加载话题缓存失败: {e}") + + async def _load_batch_from_disk(self): + """在启动时加载聊天批次，支持重启后继续""" + try: + if not self._topic_cache_file.exists(): + return + + with self._topic_cache_file.open("r", encoding="utf-8") as f: + data = json.load(f) + + batch_data = data.get("current_batch") + if not batch_data: + return + + start_time = batch_data.get("start_time") + end_time = batch_data.get("end_time") + if not start_time or not end_time: + return + + # 根据时间范围重新查询消息 + messages = message_api.get_messages_by_time_in_chat( + chat_id=self.chat_id, + start_time=start_time, + end_time=end_time, + limit=0, + limit_mode="latest", + filter_mai=False, + filter_command=False, + ) + + if messages: + self.current_batch = MessageBatch( + messages=messages, + start_time=start_time, + end_time=end_time, + ) + logger.info(f"{self.log_prefix} 已恢复聊天批次，包含 {len(messages)} 条消息") + except Exception as e: + logger.error(f"{self.log_prefix} 加载聊天批次失败: {e}") + + def _persist_topic_cache(self): + """实时持久化话题缓存和聊天批次，避免重启后丢失""" + try: + # 如果既没有话题缓存也没有批次，删除缓存文件 + if not self.topic_cache and not self.current_batch: + if self._topic_cache_file.exists(): + self._topic_cache_file.unlink() + return + + HIPPO_CACHE_DIR.mkdir(parents=True, exist_ok=True) + data = { + "chat_id": self.chat_id, + "last_topic_check_time": self.last_topic_check_time, + "topics": { + topic: { + "messages": item.messages, + "participants": list(item.participants), + "no_update_checks": item.no_update_checks, + } + for topic, item in self.topic_cache.items() + }, + } + + # 保存当前批次的时间范围（如果有） + if self.current_batch: + data["current_batch"] = { + "start_time": self.current_batch.start_time, + "end_time": self.current_batch.end_time, + } + + with self._topic_cache_file.open("w", encoding="utf-8") as f: + json.dump(data, f, ensure_ascii=False, indent=2) + except Exception as e: + logger.error(f"{self.log_prefix} 持久化话题缓存失败: {e}") + + async def process(self, current_time: Optional[float] = None): + """ + 处理聊天内容概括 + + Args: + current_time: 当前时间戳，如果为None则使用time.time() + """ + if current_time is None: + current_time = time.time() + + try: + # 获取从上次检查时间到当前时间的新消息 + new_messages = message_api.get_messages_by_time_in_chat( + chat_id=self.chat_id, + start_time=self.last_check_time, + end_time=current_time, + limit=0, + limit_mode="latest", + filter_mai=False, # 不过滤bot消息，因为需要检查bot是否发言 + filter_command=False, + ) + + if not new_messages: + # 没有新消息，检查是否需要进行“话题检查” + if self.current_batch and self.current_batch.messages: + await self._check_and_run_topic_check(current_time) + self.last_check_time = current_time + return + + logger.debug( + f"{self.log_prefix} 开始处理聊天概括，时间窗口: {self.last_check_time:.2f} -> {current_time:.2f}" + ) + + # 有新消息，更新最后检查时间 + self.last_check_time = current_time + + # 如果有当前批次，添加新消息 + if self.current_batch: + before_count = len(self.current_batch.messages) + self.current_batch.messages.extend(new_messages) + self.current_batch.end_time = current_time + logger.info( + f"{self.log_prefix} 更新聊天检查批次: {before_count} -> {len(self.current_batch.messages)} 条消息" + ) + # 更新批次后持久化 + self._persist_topic_cache() + else: + # 创建新批次 + self.current_batch = MessageBatch( + messages=new_messages, + start_time=new_messages[0].time if new_messages else current_time, + end_time=current_time, + ) + logger.debug(f"{self.log_prefix} 新建聊天检查批次: {len(new_messages)} 条消息") + # 创建批次后持久化 + self._persist_topic_cache() + + # 检查是否需要触发“话题检查” + await self._check_and_run_topic_check(current_time) + + except Exception as e: + logger.error(f"{self.log_prefix} 处理聊天内容概括时出错: {e}") + import traceback + + traceback.print_exc() + + async def _check_and_run_topic_check(self, current_time: float): + """ + 检查是否需要进行一次“话题检查” + + 触发条件： + - 当前批次消息数 >= 100，或者 + - 距离上一次检查的时间 > 3600 秒（1小时） + """ + if not self.current_batch or not self.current_batch.messages: + return + + messages = self.current_batch.messages + message_count = len(messages) + time_since_last_check = current_time - self.last_topic_check_time + + # 格式化时间差显示 + if time_since_last_check < 60: + time_str = f"{time_since_last_check:.1f}秒" + elif time_since_last_check < 3600: + time_str = f"{time_since_last_check / 60:.1f}分钟" + else: + time_str = f"{time_since_last_check / 3600:.1f}小时" + + logger.debug(f"{self.log_prefix} 批次状态检查 | 消息数: {message_count} | 距上次检查: {time_str}") + + # 检查“话题检查”触发条件 + should_check = False + + # 条件1: 消息数量 >= 100，触发一次检查 + if message_count >= 80: + should_check = True + logger.info(f"{self.log_prefix} 触发检查条件: 消息数量达到 {message_count} 条（阈值: 100条）") + + # 条件2: 距离上一次检查 > 3600 * 8 秒（8小时）且消息数量 >= 20 条，触发一次检查 + elif time_since_last_check > 3600 * 8 and message_count >= 20: + should_check = True + logger.info(f"{self.log_prefix} 触发检查条件: 距上次检查 {time_str}（阈值: 8小时）且消息数量达到 {message_count} 条（阈值: 20条）") + + if should_check: + await self._run_topic_check_and_update_cache(messages) + # 本批次已经被处理为话题信息，可以清空 + self.current_batch = None + # 更新上一次检查时间，并持久化 + self.last_topic_check_time = current_time + self._persist_topic_cache() + + async def _run_topic_check_and_update_cache(self, messages: List[DatabaseMessages]): + """ + 执行一次“话题检查”： + 1. 首先确认这段消息里是否有 Bot 发言，没有则直接丢弃本次批次； + 2. 将消息编号并转成字符串，构造 LLM Prompt； + 3. 把历史话题标题列表放入 Prompt，要求 LLM： + - 识别当前聊天中的话题（1 个或多个）； + - 为每个话题选出相关消息编号； + - 若话题属于历史话题，则沿用原话题标题； + 4. LLM 返回 JSON：多个 {topic, message_indices}； + 5. 更新本地话题缓存，并根据规则触发“话题打包存储”。 + """ + if not messages: + return + + start_time = messages[0].time + end_time = messages[-1].time + + logger.info( + f"{self.log_prefix} 开始话题检查 | 消息数: {len(messages)} | 时间范围: {start_time:.2f} - {end_time:.2f}" + ) + + # 1. 检查当前批次内是否有 bot 发言（只检查当前批次，不往前推） + # 原因：我们要记录的是 bot 参与过的对话片段，如果当前批次内 bot 没有发言， + # 说明 bot 没有参与这段对话，不应该记录 + bot_user_id = str(global_config.bot.qq_account) + has_bot_message = False + + for msg in messages: + if msg.user_info.user_id == bot_user_id: + has_bot_message = True + break + + if not has_bot_message: + logger.info( + f"{self.log_prefix} 当前批次内无 Bot 发言，丢弃本次检查 | 时间范围: {start_time:.2f} - {end_time:.2f}" + ) + return + + # 2. 构造编号后的消息字符串和参与者信息 + numbered_lines, index_to_msg_str, index_to_msg_text, index_to_participants = ( + self._build_numbered_messages_for_llm(messages) + ) + + # 3. 调用 LLM 识别话题，并得到 topic -> indices（失败时最多重试 3 次） + existing_topics = list(self.topic_cache.keys()) + max_retries = 3 + attempt = 0 + success = False + topic_to_indices: Dict[str, List[int]] = {} + + while attempt < max_retries: + attempt += 1 + success, topic_to_indices = await self._analyze_topics_with_llm( + numbered_lines=numbered_lines, + existing_topics=existing_topics, + ) + + if success and topic_to_indices: + if attempt > 1: + logger.info( + f"{self.log_prefix} 话题识别在第 {attempt} 次重试后成功 | 话题数: {len(topic_to_indices)}" + ) + break + + logger.warning( + f"{self.log_prefix} 话题识别失败或无有效话题，第 {attempt} 次尝试失败" + + ("" if attempt >= max_retries else "，准备重试") + ) + + if not success or not topic_to_indices: + logger.error(f"{self.log_prefix} 话题识别连续 {max_retries} 次失败或始终无有效话题，本次检查放弃") + # 即使识别失败，也认为是一次"检查"，但不更新 no_update_checks（保持原状） + return + + # 3.5. 检查新话题是否与历史话题相似（相似度>=90%则使用历史标题） + topic_mapping = self._build_topic_mapping(topic_to_indices, similarity_threshold=0.9) + + # 应用话题映射：将相似的新话题标题替换为历史话题标题 + if topic_mapping: + new_topic_to_indices: Dict[str, List[int]] = {} + for new_topic, indices in topic_to_indices.items(): + # 如果这个新话题需要映射到历史话题 + if new_topic in topic_mapping: + historical_topic = topic_mapping[new_topic] + # 如果历史话题已经存在，合并消息索引 + if historical_topic in new_topic_to_indices: + # 合并索引并去重 + combined_indices = list(set(new_topic_to_indices[historical_topic] + indices)) + new_topic_to_indices[historical_topic] = combined_indices + else: + new_topic_to_indices[historical_topic] = indices + else: + # 不需要映射，保持原样 + new_topic_to_indices[new_topic] = indices + topic_to_indices = new_topic_to_indices + + # 4. 统计哪些话题在本次检查中有新增内容 + updated_topics: Set[str] = set() + + for topic, indices in topic_to_indices.items(): + if not indices: + continue + + item = self.topic_cache.get(topic) + if not item: + # 新话题 + item = TopicCacheItem(topic=topic) + self.topic_cache[topic] = item + + # 收集属于该话题的消息文本（不带编号） + topic_msg_texts: List[str] = [] + new_participants: Set[str] = set() + for idx in indices: + msg_text = index_to_msg_text.get(idx) + if not msg_text: + continue + topic_msg_texts.append(msg_text) + new_participants.update(index_to_participants.get(idx, set())) + + if not topic_msg_texts: + continue + + # 将本次检查中属于该话题的所有消息合并为一个字符串（不带编号） + merged_text = "\n".join(topic_msg_texts) + item.messages.append(merged_text) + item.participants.update(new_participants) + # 本次检查中该话题有更新，重置计数 + item.no_update_checks = 0 + updated_topics.add(topic) + + # 5. 对于本次没有更新的历史话题，no_update_checks + 1 + for topic, item in list(self.topic_cache.items()): + if topic not in updated_topics: + item.no_update_checks += 1 + + # 6. 检查是否有话题需要打包存储 + topics_to_finalize: List[str] = [] + for topic, item in self.topic_cache.items(): + if item.no_update_checks >= 3: + logger.info(f"{self.log_prefix} 话题[{topic}] 连续 3 次检查无新增内容，触发打包存储") + topics_to_finalize.append(topic) + continue + if len(item.messages) > 5: + logger.info(f"{self.log_prefix} 话题[{topic}] 消息条数超过 4，触发打包存储") + topics_to_finalize.append(topic) + + for topic in topics_to_finalize: + item = self.topic_cache.get(topic) + if not item: + continue + try: + await self._finalize_and_store_topic( + topic=topic, + item=item, + # 这里的时间范围尽量覆盖最近一次检查的区间 + start_time=start_time, + end_time=end_time, + ) + finally: + # 无论成功与否，都从缓存中删除，避免重复 + self.topic_cache.pop(topic, None) + + def _find_most_similar_topic( + self, new_topic: str, existing_topics: List[str], similarity_threshold: float = 0.9 + ) -> Optional[tuple[str, float]]: + """ + 查找与给定新话题最相似的历史话题 + + Args: + new_topic: 新话题标题 + existing_topics: 历史话题标题列表 + similarity_threshold: 相似度阈值，默认0.9（90%） + + Returns: + Optional[tuple[str, float]]: 如果找到相似度>=阈值的历史话题，返回(历史话题标题, 相似度)， + 否则返回None + """ + if not existing_topics: + return None + + best_match = None + best_similarity = 0.0 + + for existing_topic in existing_topics: + similarity = difflib.SequenceMatcher(None, new_topic, existing_topic).ratio() + if similarity > best_similarity: + best_similarity = similarity + best_match = existing_topic + + # 如果相似度达到阈值，返回匹配结果 + if best_match and best_similarity >= similarity_threshold: + return (best_match, best_similarity) + + return None + + def _build_topic_mapping( + self, topic_to_indices: Dict[str, List[int]], similarity_threshold: float = 0.9 + ) -> Dict[str, str]: + """ + 构建新话题到历史话题的映射（如果相似度>=阈值） + + Args: + topic_to_indices: 新话题到消息索引的映射 + similarity_threshold: 相似度阈值，默认0.9（90%） + + Returns: + Dict[str, str]: 新话题 -> 历史话题的映射字典 + """ + existing_topics_list = list(self.topic_cache.keys()) + topic_mapping: Dict[str, str] = {} + + for new_topic in topic_to_indices.keys(): + # 如果新话题已经在历史话题中，不需要检查 + if new_topic in existing_topics_list: + continue + + # 查找最相似的历史话题 + result = self._find_most_similar_topic(new_topic, existing_topics_list, similarity_threshold) + if result: + historical_topic, similarity = result + topic_mapping[new_topic] = historical_topic + logger.info( + f"{self.log_prefix} 话题相似度检查: '{new_topic}' 与历史话题 '{historical_topic}' 相似度 {similarity:.2%}，使用历史标题" + ) + + return topic_mapping + + def _build_numbered_messages_for_llm( + self, messages: List[DatabaseMessages] + ) -> tuple[List[str], Dict[int, str], Dict[int, str], Dict[int, Set[str]]]: + """ + 将消息转为带编号的字符串，供 LLM 选择使用。 + + 返回: + numbered_lines: ["1. xxx", "2. yyy", ...] # 带编号，用于 LLM 选择 + index_to_msg_str: idx -> "idx. xxx" # 带编号，用于 LLM 选择 + index_to_msg_text: idx -> "xxx" # 不带编号，用于最终存储 + index_to_participants: idx -> {nickname1, nickname2, ...} + """ + numbered_lines: List[str] = [] + index_to_msg_str: Dict[int, str] = {} + index_to_msg_text: Dict[int, str] = {} # 不带编号的消息文本 + index_to_participants: Dict[int, Set[str]] = {} + + for idx, msg in enumerate(messages, start=1): + # 使用 build_readable_messages 生成可读文本 + try: + text = build_readable_messages( + messages=[msg], + replace_bot_name=True, + timestamp_mode="normal_no_YMD", + read_mark=0.0, + truncate=False, + show_actions=False, + ).strip() + except Exception: + # 回退到简单文本 + text = getattr(msg, "processed_plain_text", "") or "" + + # 获取发言人昵称 + participants: Set[str] = set() + try: + platform = ( + getattr(msg, "user_platform", None) + or (msg.user_info.platform if msg.user_info else None) + or msg.chat_info.platform + ) + user_id = msg.user_info.user_id if msg.user_info else None + if platform and user_id: + person = Person(platform=platform, user_id=user_id) + if person.person_name: + participants.add(person.person_name) + except Exception: + pass + + # 带编号的字符串（用于 LLM 选择） + line = f"{idx}. {text}" + numbered_lines.append(line) + index_to_msg_str[idx] = line + # 不带编号的文本（用于最终存储） + index_to_msg_text[idx] = text + index_to_participants[idx] = participants + + return numbered_lines, index_to_msg_str, index_to_msg_text, index_to_participants + + async def _analyze_topics_with_llm( + self, + numbered_lines: List[str], + existing_topics: List[str], + ) -> tuple[bool, Dict[str, List[int]]]: + """ + 使用 LLM 识别本次检查中的话题，并为每个话题选择相关消息编号。 + + 要求： + - 话题用一句话清晰描述正在发生的事件，包括时间、人物、主要事件和主题； + - 可以有 1 个或多个话题； + - 若某个话题与历史话题列表中的某个话题是同一件事，请直接使用历史话题的字符串； + - 输出 JSON，格式： + [ + { + "topic": "话题标题字符串", + "message_indices": [1, 2, 5] + }, + ... + ] + """ + if not numbered_lines: + return False, {} + + history_topics_block = "\n".join(f"- {t}" for t in existing_topics) if existing_topics else "（当前无历史话题）" + messages_block = "\n".join(numbered_lines) + + prompt = await global_prompt_manager.format_prompt( + "hippo_topic_analysis_prompt", + history_topics_block=history_topics_block, + messages_block=messages_block, + ) + + try: + response, _ = await self.summarizer_llm.generate_response_async( + prompt=prompt, + temperature=0.3, + ) + + logger.info(f"{self.log_prefix} 话题识别LLM Prompt: {prompt}") + logger.info(f"{self.log_prefix} 话题识别LLM Response: {response}") + + # 尝试从响应中提取JSON代码块 + json_str = None + json_pattern = r"```json\s*(.*?)\s*```" + matches = re.findall(json_pattern, response, re.DOTALL) + + if matches: + # 找到JSON代码块，使用第一个匹配 + json_str = matches[0].strip() + else: + # 如果没有找到代码块，尝试查找JSON数组的开始和结束位置 + # 查找第一个 [ 和最后一个 ] + start_idx = response.find("[") + end_idx = response.rfind("]") + if start_idx != -1 and end_idx != -1 and end_idx > start_idx: + json_str = response[start_idx : end_idx + 1].strip() + else: + # 如果还是找不到，尝试直接使用整个响应（移除可能的markdown标记） + json_str = response.strip() + json_str = re.sub(r"^```json\s*", "", json_str, flags=re.MULTILINE) + json_str = re.sub(r"^```\s*", "", json_str, flags=re.MULTILINE) + json_str = json_str.strip() + + # 使用json_repair修复可能的JSON错误 + if json_str: + try: + repaired_json = repair_json(json_str) + result = json.loads(repaired_json) if isinstance(repaired_json, str) else repaired_json + except Exception as repair_error: + # 如果repair失败，尝试直接解析 + logger.warning(f"{self.log_prefix} JSON修复失败，尝试直接解析: {repair_error}") + result = json.loads(json_str) + else: + raise ValueError("无法从响应中提取JSON内容") + + if not isinstance(result, list): + logger.error(f"{self.log_prefix} 话题识别返回的 JSON 不是列表: {result}") + return False, {} + + topic_to_indices: Dict[str, List[int]] = {} + for item in result: + if not isinstance(item, dict): + continue + topic = item.get("topic") + indices = item.get("message_indices") or item.get("messages") or [] + if not topic or not isinstance(topic, str): + continue + if isinstance(indices, list): + valid_indices: List[int] = [] + for v in indices: + try: + iv = int(v) + if iv > 0: + valid_indices.append(iv) + except (TypeError, ValueError): + continue + if valid_indices: + topic_to_indices[topic] = valid_indices + + return True, topic_to_indices + + except Exception as e: + logger.error(f"{self.log_prefix} 话题识别 LLM 调用或解析失败: {e}") + logger.error(f"{self.log_prefix} LLM响应: {response if 'response' in locals() else 'N/A'}") + return False, {} + + async def _finalize_and_store_topic( + self, + topic: str, + item: TopicCacheItem, + start_time: float, + end_time: float, + ): + """ + 对某个话题进行最终打包存储： + 1. 将 messages(list[str]) 拼接为 original_text； + 2. 使用 LLM 对 original_text 进行总结，得到 summary 和 keywords，theme 直接使用话题字符串； + 3. 写入数据库 ChatHistory； + 4. 完成后，调用方会从缓存中删除该话题。 + """ + if not item.messages: + logger.info(f"{self.log_prefix} 话题[{topic}] 无消息内容，跳过打包") + return + + original_text = "\n".join(item.messages) + + logger.info( + f"{self.log_prefix} 开始打包话题[{topic}] | 消息数: {len(item.messages)} | 时间范围: {start_time:.2f} - {end_time:.2f}" + ) + + # 使用 LLM 进行总结（基于话题名） + success, keywords, summary, key_point = await self._compress_with_llm(original_text, topic) + if not success: + logger.warning(f"{self.log_prefix} 话题[{topic}] LLM 概括失败，不写入数据库") + return + + participants = list(item.participants) + + await self._store_to_database( + start_time=start_time, + end_time=end_time, + original_text=original_text, + participants=participants, + theme=topic, # 主题直接使用话题名 + keywords=keywords, + summary=summary, + key_point=key_point, + ) + + logger.info( + f"{self.log_prefix} 话题[{topic}] 成功打包并存储 | 消息数: {len(item.messages)} | 参与者数: {len(participants)}" + ) + + async def _compress_with_llm(self, original_text: str, topic: str) -> tuple[bool, List[str], str, List[str]]: + """ + 使用LLM压缩聊天内容（用于单个话题的最终总结） + + Args: + original_text: 聊天记录原文 + topic: 话题名称 + + Returns: + tuple[bool, List[str], str, List[str]]: (是否成功, 关键词列表, 概括, 关键信息列表) + """ + prompt = await global_prompt_manager.format_prompt( + "hippo_topic_summary_prompt", + topic=topic, + original_text=original_text, + ) + + try: + response, _ = await self.summarizer_llm.generate_response_async( + prompt=prompt, + temperature=0.3, + max_tokens=500, + ) + + # 解析JSON响应 + json_str = response.strip() + json_str = re.sub(r"^```json\s*", "", json_str, flags=re.MULTILINE) + json_str = re.sub(r"^```\s*", "", json_str, flags=re.MULTILINE) + json_str = json_str.strip() + + # 查找JSON对象的开始与结束 + start_idx = json_str.find("{") + if start_idx == -1: + raise ValueError("未找到JSON对象开始标记") + + end_idx = json_str.rfind("}") + if end_idx == -1 or end_idx <= start_idx: + logger.warning(f"{self.log_prefix} JSON缺少结束标记，尝试自动修复") + extracted_json = json_str[start_idx:] + else: + extracted_json = json_str[start_idx : end_idx + 1] + + def _parse_with_quote_fix(payload: str) -> Dict[str, Any]: + fixed_chars: List[str] = [] + in_string = False + escape_next = False + i = 0 + while i < len(payload): + char = payload[i] + if escape_next: + fixed_chars.append(char) + escape_next = False + elif char == "\\": + fixed_chars.append(char) + escape_next = True + elif char == '"' and not escape_next: + fixed_chars.append(char) + in_string = not in_string + elif in_string and char in {"“", "”"}: + # 在字符串值内部，将中文引号替换为转义的英文引号 + fixed_chars.append('\\"') + else: + fixed_chars.append(char) + i += 1 + + repaired = "".join(fixed_chars) + return json.loads(repaired) + + try: + result = json.loads(extracted_json) + except json.JSONDecodeError: + try: + repaired_json = repair_json(extracted_json) + if isinstance(repaired_json, str): + result = json.loads(repaired_json) + else: + result = repaired_json + except Exception as repair_error: + logger.warning(f"{self.log_prefix} repair_json 失败，使用引号修复: {repair_error}") + result = _parse_with_quote_fix(extracted_json) + + keywords = result.get("keywords", []) + summary = result.get("summary", "无概括") + key_point = result.get("key_point", []) + + # 确保keywords和key_point是列表 + if isinstance(keywords, str): + keywords = [keywords] + if isinstance(key_point, str): + key_point = [key_point] + + return True, keywords, summary, key_point + + except Exception as e: + logger.error(f"{self.log_prefix} LLM压缩聊天内容时出错: {e}") + logger.error(f"{self.log_prefix} LLM响应: {response if 'response' in locals() else 'N/A'}") + # 返回失败标志和默认值 + return False, [], "压缩失败，无法生成概括", [] + + async def _store_to_database( + self, + start_time: float, + end_time: float, + original_text: str, + participants: List[str], + theme: str, + keywords: List[str], + summary: str, + key_point: Optional[List[str]] = None, + ): + """存储到数据库""" + try: + from src.common.database.database_model import ChatHistory + from src.plugin_system.apis import database_api + + # 准备数据 + data = { + "chat_id": self.chat_id, + "start_time": start_time, + "end_time": end_time, + "original_text": original_text, + "participants": json.dumps(participants, ensure_ascii=False), + "theme": theme, + "keywords": json.dumps(keywords, ensure_ascii=False), + "summary": summary, + "count": 0, + } + + # 存储 key_point（如果存在） + if key_point is not None: + data["key_point"] = json.dumps(key_point, ensure_ascii=False) + + # 使用db_save存储（使用start_time和chat_id作为唯一标识） + # 由于可能有多条记录，我们使用组合键，但peewee不支持，所以使用start_time作为唯一标识 + # 但为了避免冲突，我们使用组合键：chat_id + start_time + # 由于peewee不支持组合键，我们直接创建新记录（不提供key_field和key_value） + saved_record = await database_api.db_save( + ChatHistory, + data=data, + ) + + if saved_record: + logger.debug(f"{self.log_prefix} 成功存储聊天历史记录到数据库") + else: + logger.warning(f"{self.log_prefix} 存储聊天历史记录到数据库失败") + + except Exception as e: + logger.error(f"{self.log_prefix} 存储到数据库时出错: {e}") + import traceback + + traceback.print_exc() + raise + + async def start(self): + """启动后台定期检查循环""" + if self._running: + logger.warning(f"{self.log_prefix} 后台循环已在运行，无需重复启动") + return + + # 加载聊天批次（如果有） + await self._load_batch_from_disk() + + self._running = True + self._periodic_task = asyncio.create_task(self._periodic_check_loop()) + logger.info(f"{self.log_prefix} 已启动后台定期检查循环 | 检查间隔: {self.check_interval}秒") + + async def stop(self): + """停止后台定期检查循环""" + self._running = False + if self._periodic_task: + self._periodic_task.cancel() + try: + await self._periodic_task + except asyncio.CancelledError: + pass + self._periodic_task = None + logger.info(f"{self.log_prefix} 已停止后台定期检查循环") + + async def _periodic_check_loop(self): + """后台定期检查循环""" + try: + while self._running: + # 执行一次检查 + await self.process() + + # 等待指定间隔后再次检查 + await asyncio.sleep(self.check_interval) + except asyncio.CancelledError: + logger.info(f"{self.log_prefix} 后台检查循环被取消") + raise + except Exception as e: + logger.error(f"{self.log_prefix} 后台检查循环出错: {e}") + import traceback + + traceback.print_exc() + self._running = False + + +init_prompt() diff --git a/src/chat/utils/memory_forget_task.py b/src/hippo_memorizer/memory_forget_task.py similarity index 97% rename from src/chat/utils/memory_forget_task.py rename to src/hippo_memorizer/memory_forget_task.py index 15a912b4..ce2a9b2a 100644 --- a/src/chat/utils/memory_forget_task.py +++ b/src/hippo_memorizer/memory_forget_task.py @@ -25,15 +25,15 @@ class MemoryForgetTask(AsyncTask): """执行遗忘检查""" try: current_time = time.time() - logger.info("[记忆遗忘] 开始遗忘检查...") + # logger.info("[记忆遗忘] 开始遗忘检查...") # 执行4个阶段的遗忘检查 - await self._forget_stage_1(current_time) - await self._forget_stage_2(current_time) - await self._forget_stage_3(current_time) - await self._forget_stage_4(current_time) + # await self._forget_stage_1(current_time) + # await self._forget_stage_2(current_time) + # await self._forget_stage_3(current_time) + # await self._forget_stage_4(current_time) - logger.info("[记忆遗忘] 遗忘检查完成") + # logger.info("[记忆遗忘] 遗忘检查完成") except Exception as e: logger.error(f"[记忆遗忘] 执行遗忘检查时出错: {e}", exc_info=True) diff --git a/src/jargon/__init__.py b/src/jargon/__init__.py deleted file mode 100644 index 37b61644..00000000 --- a/src/jargon/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ -from .jargon_miner import extract_and_store_jargon - -__all__ = [ - "extract_and_store_jargon", -] diff --git a/src/jargon/jargon_miner.py b/src/jargon/jargon_miner.py deleted file mode 100644 index 4319ad3d..00000000 --- a/src/jargon/jargon_miner.py +++ /dev/null @@ -1,858 +0,0 @@ -import time -import json -import asyncio -from typing import List, Dict, Optional, Any -from json_repair import repair_json -from peewee import fn - -from src.common.logger import get_logger -from src.common.database.database_model import Jargon -from src.llm_models.utils_model import LLMRequest -from src.config.config import model_config, global_config -from src.chat.message_receive.chat_stream import get_chat_manager -from src.plugin_system.apis import llm_api -from src.chat.utils.chat_message_builder import ( - build_anonymous_messages, - get_raw_msg_by_timestamp_with_chat_inclusive, - get_raw_msg_before_timestamp_with_chat, - build_readable_messages_with_list, -) -from src.chat.utils.prompt_builder import Prompt, global_prompt_manager - - -logger = get_logger("jargon") - - -def _contains_bot_self_name(content: str) -> bool: - """ - 判断词条是否包含机器人的昵称或别名 - """ - if not content: - return False - - bot_config = getattr(global_config, "bot", None) - if not bot_config: - return False - - target = content.strip().lower() - nickname = str(getattr(bot_config, "nickname", "") or "").strip().lower() - alias_names = [str(alias or "").strip().lower() for alias in getattr(bot_config, "alias_names", []) or []] - - candidates = [name for name in [nickname, *alias_names] if name] - - return any(name in target for name in candidates if target) - - -def _init_prompt() -> None: - prompt_str = """ -**聊天内容，其中的SELF是你自己的发言** -{chat_str} - -请从上面这段聊天内容中提取"可能是黑话"的候选项（黑话/俚语/网络缩写/口头禅）。 -- 必须为对话中真实出现过的短词或短语 -- 必须是你无法理解含义的词语，没有明确含义的词语 -- 请不要选择有明确含义，或者含义清晰的词语 -- 排除：人名、@、表情包/图片中的内容、纯标点、常规功能词（如的、了、呢、啊等） -- 每个词条长度建议 2-8 个字符（不强制），尽量短小 -- 合并重复项，去重 - -黑话必须为以下几种类型： -- 由字母构成的，汉语拼音首字母的简写词，例如：nb、yyds、xswl -- 英文词语的缩写，用英文字母概括一个词汇或含义，例如：CPU、GPU、API -- 中文词语的缩写，用几个汉字概括一个词汇或含义，例如：社死、内卷 - -以 JSON 数组输出，元素为对象（严格按以下结构）： -[ - {{"content": "词条", "raw_content": "包含该词条的完整对话上下文原文"}}, - {{"content": "词条2", "raw_content": "包含该词条的完整对话上下文原文"}} -] - -现在请输出： -""" - Prompt(prompt_str, "extract_jargon_prompt") - - -def _init_inference_prompts() -> None: - """初始化含义推断相关的prompt""" - # Prompt 1: 基于raw_content和content推断 - prompt1_str = """ -**词条内容** -{content} -**词条出现的上下文（raw_content）其中的SELF是你自己的发言** -{raw_content_list} - -请根据以上词条内容和上下文，推断这个词条的含义。 -- 如果这是一个黑话、俚语或网络用语，请推断其含义 -- 如果含义明确（常规词汇），也请说明 -- 如果上下文信息不足，无法推断含义，请设置 no_info 为 true - -以 JSON 格式输出： -{{ - "meaning": "详细含义说明（包含使用场景、来源、具体解释等）", - "no_info": false -}} -注意：如果信息不足无法推断，请设置 "no_info": true，此时 meaning 可以为空字符串 -""" - Prompt(prompt1_str, "jargon_inference_with_context_prompt") - - # Prompt 2: 仅基于content推断 - prompt2_str = """ -**词条内容** -{content} - -请仅根据这个词条本身，推断其含义。 -- 如果这是一个黑话、俚语或网络用语，请推断其含义 -- 如果含义明确（常规词汇），也请说明 - -以 JSON 格式输出： -{{ - "meaning": "详细含义说明（包含使用场景、来源、具体解释等）" -}} -""" - Prompt(prompt2_str, "jargon_inference_content_only_prompt") - - # Prompt 3: 比较两个推断结果 - prompt3_str = """ -**推断结果1（基于上下文）** -{inference1} - -**推断结果2（仅基于词条）** -{inference2} - -请比较这两个推断结果，判断它们是否相同或类似。 -- 如果两个推断结果的"含义"相同或类似，说明这个词条不是黑话（含义明确） -- 如果两个推断结果有差异，说明这个词条可能是黑话（需要上下文才能理解） - -以 JSON 格式输出： -{{ - "is_similar": true/false, - "reason": "判断理由" -}} -""" - Prompt(prompt3_str, "jargon_compare_inference_prompt") - - -_init_prompt() -_init_inference_prompts() - - -async def _enrich_raw_content_if_needed( - content: str, - raw_content_list: List[str], - chat_id: str, - messages: List[Any], - extraction_start_time: float, - extraction_end_time: float, -) -> List[str]: - """ - 检查raw_content是否只包含黑话本身，如果是，则获取该消息的前三条消息作为原始内容 - - Args: - content: 黑话内容 - raw_content_list: 原始raw_content列表 - chat_id: 聊天ID - messages: 当前时间窗口内的消息列表 - extraction_start_time: 提取开始时间 - extraction_end_time: 提取结束时间 - - Returns: - 处理后的raw_content列表 - """ - enriched_list = [] - - for raw_content in raw_content_list: - # 检查raw_content是否只包含黑话本身（去除空白字符后比较） - raw_content_clean = raw_content.strip() - content_clean = content.strip() - - # 如果raw_content只包含黑话本身（可能有一些标点或空白），则尝试获取上下文 - # 去除所有空白字符后比较，确保只包含黑话本身 - raw_content_normalized = raw_content_clean.replace(" ", "").replace("\n", "").replace("\t", "") - content_normalized = content_clean.replace(" ", "").replace("\n", "").replace("\t", "") - - if raw_content_normalized == content_normalized: - # 在消息列表中查找只包含该黑话的消息（去除空白后比较） - target_message = None - for msg in messages: - msg_content = (msg.processed_plain_text or msg.display_message or "").strip() - msg_content_normalized = msg_content.replace(" ", "").replace("\n", "").replace("\t", "") - # 检查消息内容是否只包含黑话本身（去除空白后完全匹配） - if msg_content_normalized == content_normalized: - target_message = msg - break - - if target_message and target_message.time: - # 获取该消息的前三条消息 - try: - previous_messages = get_raw_msg_before_timestamp_with_chat( - chat_id=chat_id, timestamp=target_message.time, limit=3 - ) - - if previous_messages: - # 将前三条消息和当前消息一起格式化 - context_messages = previous_messages + [target_message] - # 按时间排序 - context_messages.sort(key=lambda x: x.time or 0) - - # 格式化为可读消息 - formatted_context, _ = await build_readable_messages_with_list( - context_messages, - replace_bot_name=True, - timestamp_mode="relative", - truncate=False, - ) - - if formatted_context.strip(): - enriched_list.append(formatted_context.strip()) - logger.warning(f"为黑话 {content} 补充了上下文消息") - else: - # 如果格式化失败，使用原始raw_content - enriched_list.append(raw_content) - else: - # 没有找到前三条消息，使用原始raw_content - enriched_list.append(raw_content) - except Exception as e: - logger.warning(f"获取黑话 {content} 的上下文消息失败: {e}") - # 出错时使用原始raw_content - enriched_list.append(raw_content) - else: - # 没有找到包含黑话的消息，使用原始raw_content - enriched_list.append(raw_content) - else: - # raw_content包含更多内容，直接使用 - enriched_list.append(raw_content) - - return enriched_list - - -def _should_infer_meaning(jargon_obj: Jargon) -> bool: - """ - 判断是否需要进行含义推断 - 在 count 达到 3,6, 10, 20, 40, 60, 100 时进行推断 - 并且count必须大于last_inference_count，避免重启后重复判定 - 如果is_complete为True，不再进行推断 - """ - # 如果已完成所有推断，不再推断 - if jargon_obj.is_complete: - return False - - count = jargon_obj.count or 0 - last_inference = jargon_obj.last_inference_count or 0 - - # 阈值列表：3,6, 10, 20, 40, 60, 100 - thresholds = [3, 6, 10, 20, 40, 60, 100] - - if count < thresholds[0]: - return False - - # 如果count没有超过上次判定值，不需要判定 - if count <= last_inference: - return False - - # 找到第一个大于last_inference的阈值 - next_threshold = None - for threshold in thresholds: - if threshold > last_inference: - next_threshold = threshold - break - - # 如果没有找到下一个阈值，说明已经超过100，不应该再推断 - if next_threshold is None: - return False - - # 检查count是否达到或超过这个阈值 - return count >= next_threshold - - -class JargonMiner: - def __init__(self, chat_id: str) -> None: - self.chat_id = chat_id - self.last_learning_time: float = time.time() - # 频率控制，可按需调整 - self.min_messages_for_learning: int = 10 - self.min_learning_interval: float = 20 - - self.llm = LLMRequest( - model_set=model_config.model_task_config.utils, - request_type="jargon.extract", - ) - - # 初始化stream_name作为类属性，避免重复提取 - chat_manager = get_chat_manager() - stream_name = chat_manager.get_stream_name(self.chat_id) - self.stream_name = stream_name if stream_name else self.chat_id - - async def _infer_meaning_by_id(self, jargon_id: int) -> None: - """通过ID加载对象并推断""" - try: - jargon_obj = Jargon.get_by_id(jargon_id) - # 再次检查is_complete，因为可能在异步任务执行时已被标记为完成 - if jargon_obj.is_complete: - logger.debug(f"jargon {jargon_obj.content} 已完成所有推断，跳过") - return - await self.infer_meaning(jargon_obj) - except Exception as e: - logger.error(f"通过ID推断jargon失败: {e}") - - async def infer_meaning(self, jargon_obj: Jargon) -> None: - """ - 对jargon进行含义推断 - """ - try: - content = jargon_obj.content - raw_content_str = jargon_obj.raw_content or "" - - # 解析raw_content列表 - raw_content_list = [] - if raw_content_str: - try: - raw_content_list = ( - json.loads(raw_content_str) if isinstance(raw_content_str, str) else raw_content_str - ) - if not isinstance(raw_content_list, list): - raw_content_list = [raw_content_list] if raw_content_list else [] - except (json.JSONDecodeError, TypeError): - raw_content_list = [raw_content_str] if raw_content_str else [] - - if not raw_content_list: - logger.warning(f"jargon {content} 没有raw_content，跳过推断") - return - - # 步骤1: 基于raw_content和content推断 - raw_content_text = "\n".join(raw_content_list) - prompt1 = await global_prompt_manager.format_prompt( - "jargon_inference_with_context_prompt", - content=content, - raw_content_list=raw_content_text, - ) - - response1, _ = await self.llm.generate_response_async(prompt1, temperature=0.3) - if not response1: - logger.warning(f"jargon {content} 推断1失败：无响应") - return - - # 解析推断1结果 - inference1 = None - try: - resp1 = response1.strip() - if resp1.startswith("{") and resp1.endswith("}"): - inference1 = json.loads(resp1) - else: - repaired = repair_json(resp1) - inference1 = json.loads(repaired) if isinstance(repaired, str) else repaired - if not isinstance(inference1, dict): - logger.warning(f"jargon {content} 推断1结果格式错误") - return - except Exception as e: - logger.error(f"jargon {content} 推断1解析失败: {e}") - return - - # 检查推断1是否表示信息不足无法推断 - no_info = inference1.get("no_info", False) - meaning1 = inference1.get("meaning", "").strip() - if no_info or not meaning1: - logger.info(f"jargon {content} 推断1表示信息不足无法推断，放弃本次推断，待下次更新") - # 更新最后一次判定的count值，避免在同一阈值重复尝试 - jargon_obj.last_inference_count = jargon_obj.count or 0 - jargon_obj.save() - return - - # 步骤2: 仅基于content推断 - prompt2 = await global_prompt_manager.format_prompt( - "jargon_inference_content_only_prompt", - content=content, - ) - - response2, _ = await self.llm.generate_response_async(prompt2, temperature=0.3) - if not response2: - logger.warning(f"jargon {content} 推断2失败：无响应") - return - - # 解析推断2结果 - inference2 = None - try: - resp2 = response2.strip() - if resp2.startswith("{") and resp2.endswith("}"): - inference2 = json.loads(resp2) - else: - repaired = repair_json(resp2) - inference2 = json.loads(repaired) if isinstance(repaired, str) else repaired - if not isinstance(inference2, dict): - logger.warning(f"jargon {content} 推断2结果格式错误") - return - except Exception as e: - logger.error(f"jargon {content} 推断2解析失败: {e}") - return - - # logger.info(f"jargon {content} 推断2提示词: {prompt2}") - # logger.info(f"jargon {content} 推断2结果: {response2}") - # logger.info(f"jargon {content} 推断1提示词: {prompt1}") - # logger.info(f"jargon {content} 推断1结果: {response1}") - - if global_config.debug.show_jargon_prompt: - logger.info(f"jargon {content} 推断2提示词: {prompt2}") - logger.info(f"jargon {content} 推断2结果: {response2}") - logger.info(f"jargon {content} 推断1提示词: {prompt1}") - logger.info(f"jargon {content} 推断1结果: {response1}") - else: - logger.debug(f"jargon {content} 推断2提示词: {prompt2}") - logger.debug(f"jargon {content} 推断2结果: {response2}") - logger.debug(f"jargon {content} 推断1提示词: {prompt1}") - logger.debug(f"jargon {content} 推断1结果: {response1}") - - # 步骤3: 比较两个推断结果 - prompt3 = await global_prompt_manager.format_prompt( - "jargon_compare_inference_prompt", - inference1=json.dumps(inference1, ensure_ascii=False), - inference2=json.dumps(inference2, ensure_ascii=False), - ) - - if global_config.debug.show_jargon_prompt: - logger.info(f"jargon {content} 比较提示词: {prompt3}") - - response3, _ = await self.llm.generate_response_async(prompt3, temperature=0.3) - if not response3: - logger.warning(f"jargon {content} 比较失败：无响应") - return - - # 解析比较结果 - comparison = None - try: - resp3 = response3.strip() - if resp3.startswith("{") and resp3.endswith("}"): - comparison = json.loads(resp3) - else: - repaired = repair_json(resp3) - comparison = json.loads(repaired) if isinstance(repaired, str) else repaired - if not isinstance(comparison, dict): - logger.warning(f"jargon {content} 比较结果格式错误") - return - except Exception as e: - logger.error(f"jargon {content} 比较解析失败: {e}") - return - - # 判断是否为黑话 - is_similar = comparison.get("is_similar", False) - is_jargon = not is_similar # 如果相似，说明不是黑话；如果有差异，说明是黑话 - - # 更新数据库记录 - jargon_obj.is_jargon = is_jargon - if is_jargon: - # 是黑话，使用推断1的结果（基于上下文，更准确） - jargon_obj.meaning = inference1.get("meaning", "") - else: - # 不是黑话，也记录含义（使用推断2的结果，因为含义明确） - jargon_obj.meaning = inference2.get("meaning", "") - - # 更新最后一次判定的count值，避免重启后重复判定 - jargon_obj.last_inference_count = jargon_obj.count or 0 - - # 如果count>=100，标记为完成，不再进行推断 - if (jargon_obj.count or 0) >= 100: - jargon_obj.is_complete = True - - jargon_obj.save() - logger.debug( - f"jargon {content} 推断完成: is_jargon={is_jargon}, meaning={jargon_obj.meaning}, last_inference_count={jargon_obj.last_inference_count}, is_complete={jargon_obj.is_complete}" - ) - - # 固定输出推断结果，格式化为可读形式 - if is_jargon: - # 是黑话，输出格式：[聊天名]xxx的含义是 xxxxxxxxxxx - meaning = jargon_obj.meaning or "无详细说明" - is_global = jargon_obj.is_global - if is_global: - logger.info(f"[黑话]{content}的含义是 {meaning}") - else: - logger.info(f"[{self.stream_name}]{content}的含义是 {meaning}") - else: - # 不是黑话，输出格式：[聊天名]xxx 不是黑话 - logger.info(f"[{self.stream_name}]{content} 不是黑话") - - except Exception as e: - logger.error(f"jargon推断失败: {e}") - import traceback - - traceback.print_exc() - - def should_trigger(self) -> bool: - # 冷却时间检查 - if time.time() - self.last_learning_time < 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(), - ) - return bool(recent_messages and len(recent_messages) >= self.min_messages_for_learning) - - async def run_once(self) -> None: - try: - if not self.should_trigger(): - return - - chat_stream = get_chat_manager().get_stream(self.chat_id) - if not chat_stream: - return - - # 记录本次提取的时间窗口，避免重复提取 - extraction_start_time = self.last_learning_time - extraction_end_time = time.time() - - # 拉取学习窗口内的消息 - messages = get_raw_msg_by_timestamp_with_chat_inclusive( - chat_id=self.chat_id, - timestamp_start=extraction_start_time, - timestamp_end=extraction_end_time, - limit=20, - ) - if not messages: - return - - chat_str: str = await build_anonymous_messages(messages) - if not chat_str.strip(): - return - - prompt: str = await global_prompt_manager.format_prompt( - "extract_jargon_prompt", - chat_str=chat_str, - ) - - response, _ = await self.llm.generate_response_async(prompt, temperature=0.2) - if not response: - return - - if global_config.debug.show_jargon_prompt: - logger.info(f"jargon提取提示词: {prompt}") - logger.info(f"jargon提取结果: {response}") - - # 解析为JSON - entries: List[dict] = [] - try: - resp = response.strip() - parsed = None - if resp.startswith("[") and resp.endswith("]"): - parsed = json.loads(resp) - else: - repaired = repair_json(resp) - if isinstance(repaired, str): - parsed = json.loads(repaired) - else: - parsed = repaired - - if isinstance(parsed, dict): - parsed = [parsed] - - if not isinstance(parsed, list): - return - - for item in parsed: - if not isinstance(item, dict): - continue - content = str(item.get("content", "")).strip() - raw_content_value = item.get("raw_content", "") - - # 处理raw_content：可能是字符串或列表 - raw_content_list = [] - if isinstance(raw_content_value, list): - raw_content_list = [str(rc).strip() for rc in raw_content_value if str(rc).strip()] - # 去重 - raw_content_list = list(dict.fromkeys(raw_content_list)) - elif isinstance(raw_content_value, str): - raw_content_str = raw_content_value.strip() - if raw_content_str: - raw_content_list = [raw_content_str] - - if content and raw_content_list: - if _contains_bot_self_name(content): - logger.debug(f"解析阶段跳过包含机器人昵称/别名的词条: {content}") - continue - entries.append({"content": content, "raw_content": raw_content_list}) - except Exception as e: - logger.error(f"解析jargon JSON失败: {e}; 原始: {response}") - return - - if not entries: - return - - # 去重并写入DB（按 chat_id + content 去重） - # 使用content作为去重键 - seen = set() - uniq_entries = [] - for entry in entries: - content_key = entry["content"] - if content_key not in seen: - seen.add(content_key) - uniq_entries.append(entry) - - saved = 0 - updated = 0 - for entry in uniq_entries: - content = entry["content"] - raw_content_list = entry["raw_content"] # 已经是列表 - - # 检查并补充raw_content：如果只包含黑话本身，则获取前三条消息作为上下文 - raw_content_list = await _enrich_raw_content_if_needed( - content=content, - raw_content_list=raw_content_list, - chat_id=self.chat_id, - messages=messages, - extraction_start_time=extraction_start_time, - extraction_end_time=extraction_end_time, - ) - - try: - # 根据all_global配置决定查询逻辑 - if global_config.jargon.all_global: - # 开启all_global：无视chat_id，查询所有content匹配的记录（所有记录都是全局的） - query = Jargon.select().where(Jargon.content == content) - else: - # 关闭all_global：只查询chat_id匹配的记录（不考虑is_global） - query = Jargon.select().where((Jargon.chat_id == self.chat_id) & (Jargon.content == content)) - - if query.exists(): - obj = query.get() - try: - obj.count = (obj.count or 0) + 1 - except Exception: - obj.count = 1 - - # 合并raw_content列表：读取现有列表，追加新值，去重 - existing_raw_content = [] - if obj.raw_content: - try: - existing_raw_content = ( - json.loads(obj.raw_content) if isinstance(obj.raw_content, str) else obj.raw_content - ) - if not isinstance(existing_raw_content, list): - existing_raw_content = [existing_raw_content] if existing_raw_content else [] - except (json.JSONDecodeError, TypeError): - existing_raw_content = [obj.raw_content] if obj.raw_content else [] - - # 合并并去重 - merged_list = list(dict.fromkeys(existing_raw_content + raw_content_list)) - obj.raw_content = json.dumps(merged_list, ensure_ascii=False) - - # 开启all_global时，确保记录标记为is_global=True - if global_config.jargon.all_global: - obj.is_global = True - # 关闭all_global时，保持原有is_global不变（不修改） - - obj.save() - - # 检查是否需要推断（达到阈值且超过上次判定值） - if _should_infer_meaning(obj): - # 异步触发推断，不阻塞主流程 - # 重新加载对象以确保数据最新 - jargon_id = obj.id - asyncio.create_task(self._infer_meaning_by_id(jargon_id)) - - updated += 1 - else: - # 没找到匹配记录，创建新记录 - if global_config.jargon.all_global: - # 开启all_global：新记录默认为is_global=True - is_global_new = True - else: - # 关闭all_global：新记录is_global=False - is_global_new = False - - Jargon.create( - content=content, - raw_content=json.dumps(raw_content_list, ensure_ascii=False), - chat_id=self.chat_id, - is_global=is_global_new, - count=1, - ) - saved += 1 - except Exception as e: - logger.error(f"保存jargon失败: chat_id={self.chat_id}, content={content}, err={e}") - continue - - # 固定输出提取的jargon结果，格式化为可读形式（只要有提取结果就输出） - if uniq_entries: - # 收集所有提取的jargon内容 - jargon_list = [entry["content"] for entry in uniq_entries] - jargon_str = ",".join(jargon_list) - - # 输出格式化的结果（使用logger.info会自动应用jargon模块的颜色） - logger.info(f"[{self.stream_name}]疑似黑话: {jargon_str}") - - # 更新为本次提取的结束时间，确保不会重复提取相同的消息窗口 - self.last_learning_time = extraction_end_time - - if saved or updated: - logger.info(f"jargon写入: 新增 {saved} 条，更新 {updated} 条，chat_id={self.chat_id}") - except Exception as e: - logger.error(f"JargonMiner 运行失败: {e}") - - -class JargonMinerManager: - def __init__(self) -> None: - self._miners: dict[str, JargonMiner] = {} - - def get_miner(self, chat_id: str) -> JargonMiner: - if chat_id not in self._miners: - self._miners[chat_id] = JargonMiner(chat_id) - return self._miners[chat_id] - - -miner_manager = JargonMinerManager() - - -async def extract_and_store_jargon(chat_id: str) -> None: - miner = miner_manager.get_miner(chat_id) - await miner.run_once() - - -def search_jargon( - keyword: str, chat_id: Optional[str] = None, limit: int = 10, case_sensitive: bool = False, fuzzy: bool = True -) -> List[Dict[str, str]]: - """ - 搜索jargon，支持大小写不敏感和模糊搜索 - - Args: - keyword: 搜索关键词 - chat_id: 可选的聊天ID - - 如果开启了all_global：此参数被忽略，查询所有is_global=True的记录 - - 如果关闭了all_global：如果提供则优先搜索该聊天或global的jargon - limit: 返回结果数量限制，默认10 - case_sensitive: 是否大小写敏感，默认False（不敏感） - fuzzy: 是否模糊搜索，默认True（使用LIKE匹配） - - Returns: - List[Dict[str, str]]: 包含content, meaning的字典列表 - """ - if not keyword or not keyword.strip(): - return [] - - keyword = keyword.strip() - - # 构建查询 - query = Jargon.select(Jargon.content, Jargon.meaning) - - # 构建搜索条件 - if case_sensitive: - # 大小写敏感 - if fuzzy: - # 模糊搜索 - search_condition = Jargon.content.contains(keyword) - else: - # 精确匹配 - search_condition = Jargon.content == keyword - else: - # 大小写不敏感 - if fuzzy: - # 模糊搜索（使用LOWER函数） - search_condition = fn.LOWER(Jargon.content).contains(keyword.lower()) - else: - # 精确匹配（使用LOWER函数） - search_condition = fn.LOWER(Jargon.content) == keyword.lower() - - query = query.where(search_condition) - - # 根据all_global配置决定查询逻辑 - if global_config.jargon.all_global: - # 开启all_global：所有记录都是全局的，查询所有is_global=True的记录（无视chat_id） - query = query.where(Jargon.is_global) - else: - # 关闭all_global：如果提供了chat_id，优先搜索该聊天或global的jargon - if chat_id: - query = query.where((Jargon.chat_id == chat_id) | Jargon.is_global) - - # 只返回有meaning的记录 - query = query.where((Jargon.meaning.is_null(False)) & (Jargon.meaning != "")) - - # 按count降序排序，优先返回出现频率高的 - query = query.order_by(Jargon.count.desc()) - - # 限制结果数量 - query = query.limit(limit) - - # 执行查询并返回结果 - results = [] - for jargon in query: - results.append({"content": jargon.content or "", "meaning": jargon.meaning or ""}) - - return results - - -async def store_jargon_from_answer(jargon_keyword: str, answer: str, chat_id: str) -> None: - """将黑话存入jargon系统 - - Args: - jargon_keyword: 黑话关键词 - answer: 答案内容（将概括为raw_content） - chat_id: 聊天ID - """ - try: - # 概括答案为简短的raw_content - summary_prompt = f"""请将以下答案概括为一句简短的话（不超过50字），作为黑话"{jargon_keyword}"的使用示例： - -答案：{answer} - -只输出概括后的内容，不要输出其他内容：""" - - success, summary, _, _ = await llm_api.generate_with_model( - summary_prompt, - model_config=model_config.model_task_config.utils_small, - request_type="memory.summarize_jargon", - ) - - logger.info(f"概括答案提示: {summary_prompt}") - logger.info(f"概括答案: {summary}") - - if not success: - logger.warning(f"概括答案失败，使用原始答案: {summary}") - summary = answer[:100] # 截取前100字符作为备用 - - raw_content = summary.strip()[:200] # 限制长度 - - # 检查是否已存在 - if global_config.jargon.all_global: - query = Jargon.select().where(Jargon.content == jargon_keyword) - else: - query = Jargon.select().where((Jargon.chat_id == chat_id) & (Jargon.content == jargon_keyword)) - - if query.exists(): - # 更新现有记录 - obj = query.get() - obj.count = (obj.count or 0) + 1 - - # 合并raw_content列表 - existing_raw_content = [] - if obj.raw_content: - try: - existing_raw_content = ( - json.loads(obj.raw_content) if isinstance(obj.raw_content, str) else obj.raw_content - ) - if not isinstance(existing_raw_content, list): - existing_raw_content = [existing_raw_content] if existing_raw_content else [] - except (json.JSONDecodeError, TypeError): - existing_raw_content = [obj.raw_content] if obj.raw_content else [] - - # 合并并去重 - merged_list = list(dict.fromkeys(existing_raw_content + [raw_content])) - obj.raw_content = json.dumps(merged_list, ensure_ascii=False) - - if global_config.jargon.all_global: - obj.is_global = True - - obj.save() - logger.info(f"更新jargon记录: {jargon_keyword}") - else: - # 创建新记录 - is_global_new = True if global_config.jargon.all_global else False - Jargon.create( - content=jargon_keyword, - raw_content=json.dumps([raw_content], ensure_ascii=False), - chat_id=chat_id, - is_global=is_global_new, - count=1, - ) - logger.info(f"创建新jargon记录: {jargon_keyword}") - - except Exception as e: - logger.error(f"存储jargon失败: {e}") diff --git a/src/llm_models/exceptions.py b/src/llm_models/exceptions.py index 65e49f74..25452e0b 100644 --- a/src/llm_models/exceptions.py +++ b/src/llm_models/exceptions.py @@ -18,11 +18,12 @@ error_code_mapping = { class NetworkConnectionError(Exception): """连接异常，常见于网络问题或服务器不可用""" - def __init__(self): - super().__init__() + def __init__(self, message: str | None = None): + super().__init__(message) + self.message = message def __str__(self): - return "连接异常，请检查网络连接状态或URL是否正确" + return self.message or "连接异常，请检查网络连接状态或URL是否正确" class ReqAbortException(Exception): diff --git a/src/llm_models/model_client/gemini_client.py b/src/llm_models/model_client/gemini_client.py index b3fafca0..33afacaa 100644 --- a/src/llm_models/model_client/gemini_client.py +++ b/src/llm_models/model_client/gemini_client.py @@ -98,7 +98,10 @@ def _convert_messages( content: List[Part] = [] for item in message.content: if isinstance(item, tuple): - image_format = "jpeg" if item[0].lower() == "jpg" else item[0].lower() + image_format = item[0].lower() + # 规范 JPEG MIME 类型后缀，统一使用 image/jpeg + if image_format in ("jpg", "jpeg"): + image_format = "jpeg" content.append(Part.from_bytes(data=base64.b64decode(item[1]), mime_type=f"image/{image_format}")) elif isinstance(item, str): content.append(Part.from_text(text=item)) @@ -143,10 +146,14 @@ def _convert_tool_options(tool_options: list[ToolOption]) -> list[FunctionDeclar :param tool_option_param: 工具参数对象 :return: 转换后的工具参数字典 """ - # JSON Schema要求使用"boolean"而不是"bool" + # JSON Schema 类型名称修正： + # - 布尔类型使用 "boolean" 而不是 "bool" + # - 浮点数使用 "number" 而不是 "float" param_type_value = tool_option_param.param_type.value if param_type_value == "bool": param_type_value = "boolean" + elif param_type_value == "float": + param_type_value = "number" return_dict: dict[str, Any] = { "type": param_type_value, diff --git a/src/llm_models/model_client/openai_client.py b/src/llm_models/model_client/openai_client.py index f573d33e..5372d95b 100644 --- a/src/llm_models/model_client/openai_client.py +++ b/src/llm_models/model_client/openai_client.py @@ -61,10 +61,16 @@ def _convert_messages(messages: list[Message]) -> list[ChatCompletionMessagePara content = [] for item in message.content: if isinstance(item, tuple): + image_format = item[0].lower() + # 规范 JPEG MIME 类型后缀，统一使用 image/jpeg + if image_format in ("jpg", "jpeg"): + mime_suffix = "jpeg" + else: + mime_suffix = image_format content.append( { "type": "image_url", - "image_url": {"url": f"data:image/{item[0].lower()};base64,{item[1]}"}, + "image_url": {"url": f"data:image/{mime_suffix};base64,{item[1]}"}, } ) elif isinstance(item, str): @@ -118,10 +124,14 @@ def _convert_tool_options(tool_options: list[ToolOption]) -> list[dict[str, Any] :param tool_option_param: 工具参数对象 :return: 转换后的工具参数字典 """ - # JSON Schema要求使用"boolean"而不是"bool" + # JSON Schema 类型名称修正： + # - 布尔类型使用 "boolean" 而不是 "bool" + # - 浮点数使用 "number" 而不是 "float" param_type_value = tool_option_param.param_type.value if param_type_value == "bool": param_type_value = "boolean" + elif param_type_value == "float": + param_type_value = "number" return_dict: dict[str, Any] = { "type": param_type_value, diff --git a/src/llm_models/utils_model.py b/src/llm_models/utils_model.py index 1ed74e03..df22c9cd 100644 --- a/src/llm_models/utils_model.py +++ b/src/llm_models/utils_model.py @@ -47,6 +47,21 @@ class LLMRequest: } """模型使用量记录，用于进行负载均衡，对应为(total_tokens, penalty, usage_penalty)，惩罚值是为了能在某个模型请求不给力或正在被使用的时候进行调整""" + def _check_slow_request(self, time_cost: float, model_name: str) -> None: + """检查请求是否过慢并输出警告日志 + + Args: + time_cost: 请求耗时（秒） + model_name: 使用的模型名称 + """ + threshold = self.model_for_task.slow_threshold + if time_cost > threshold: + request_type_display = self.request_type or "未知任务" + logger.warning( + f"LLM请求耗时过长: {request_type_display} 使用模型 {model_name} 耗时 {time_cost:.1f}s（阈值: {threshold}s），请考虑使用更快的模型\n" + f" 如果你认为该警告出现得过于频繁，请调整model_config.toml中对应任务的slow_threshold至符合你实际情况的合理值" + ) + async def generate_response_for_image( self, prompt: str, @@ -86,6 +101,8 @@ class LLMRequest: if not reasoning_content and content: content, extracted_reasoning = self._extract_reasoning(content) reasoning_content = extracted_reasoning + time_cost = time.time() - start_time + self._check_slow_request(time_cost, model_info.name) if usage := response.usage: llm_usage_recorder.record_usage_to_database( model_info=model_info, @@ -93,7 +110,7 @@ class LLMRequest: user_id="system", request_type=self.request_type, endpoint="/chat/completions", - time_cost=time.time() - start_time, + time_cost=time_cost, ) return content, (reasoning_content, model_info.name, tool_calls) @@ -198,7 +215,8 @@ class LLMRequest: tool_options=tool_built, ) - logger.debug(f"LLM请求总耗时: {time.time() - start_time}") + time_cost = time.time() - start_time + logger.debug(f"LLM请求总耗时: {time_cost}") logger.debug(f"LLM生成内容: {response}") content = response.content @@ -207,6 +225,7 @@ class LLMRequest: if not reasoning_content and content: content, extracted_reasoning = self._extract_reasoning(content) reasoning_content = extracted_reasoning + self._check_slow_request(time_cost, model_info.name) if usage := response.usage: llm_usage_recorder.record_usage_to_database( model_info=model_info, @@ -214,7 +233,7 @@ class LLMRequest: user_id="system", request_type=self.request_type, endpoint="/chat/completions", - time_cost=time.time() - start_time, + time_cost=time_cost, ) return content or "", (reasoning_content, model_info.name, tool_calls) @@ -296,12 +315,30 @@ class LLMRequest: while retry_remain > 0: try: if request_type == RequestType.RESPONSE: + # 温度优先级：参数传入 > 模型级别配置 > extra_params > 任务配置 + effective_temperature = temperature + if effective_temperature is None: + effective_temperature = model_info.temperature + if effective_temperature is None: + effective_temperature = (model_info.extra_params or {}).get("temperature") + if effective_temperature is None: + effective_temperature = self.model_for_task.temperature + + # max_tokens 优先级：参数传入 > 模型级别配置 > extra_params > 任务配置 + effective_max_tokens = max_tokens + if effective_max_tokens is None: + effective_max_tokens = model_info.max_tokens + if effective_max_tokens is None: + effective_max_tokens = (model_info.extra_params or {}).get("max_tokens") + if effective_max_tokens is None: + effective_max_tokens = self.model_for_task.max_tokens + return await client.get_response( model_info=model_info, message_list=(compressed_messages or message_list), tool_options=tool_options, - max_tokens=self.model_for_task.max_tokens if max_tokens is None else max_tokens, - temperature=self.model_for_task.temperature if temperature is None else temperature, + max_tokens=effective_max_tokens, + temperature=effective_temperature, response_format=response_format, stream_response_handler=stream_response_handler, async_response_parser=async_response_parser, @@ -323,34 +360,49 @@ class LLMRequest: ) except EmptyResponseException as e: # 空回复：通常为临时问题，单独记录并重试 + original_error_info = self._get_original_error_info(e) retry_remain -= 1 if retry_remain <= 0: - logger.error(f"模型 '{model_info.name}' 在多次出现空回复后仍然失败。") + logger.error(f"模型 '{model_info.name}' 在多次出现空回复后仍然失败。{original_error_info}") raise ModelAttemptFailed(f"模型 '{model_info.name}' 重试耗尽", original_exception=e) from e - logger.warning(f"模型 '{model_info.name}' 返回空回复(可重试)。剩余重试次数: {retry_remain}") + logger.warning( + f"模型 '{model_info.name}' 返回空回复(可重试){original_error_info}。剩余重试次数: {retry_remain}" + ) await asyncio.sleep(api_provider.retry_interval) except NetworkConnectionError as e: # 网络错误：单独记录并重试 + # 尝试从链式异常中获取原始错误信息以诊断具体原因 + original_error_info = self._get_original_error_info(e) + retry_remain -= 1 if retry_remain <= 0: - logger.error(f"模型 '{model_info.name}' 在网络错误重试用尽后仍然失败。") + logger.error(f"模型 '{model_info.name}' 在网络错误重试用尽后仍然失败。{original_error_info}") raise ModelAttemptFailed(f"模型 '{model_info.name}' 重试耗尽", original_exception=e) from e - logger.warning(f"模型 '{model_info.name}' 遇到网络错误(可重试): {str(e)}。剩余重试次数: {retry_remain}") + logger.warning( + f"模型 '{model_info.name}' 遇到网络错误(可重试): {str(e)}{original_error_info}\n" + f" 常见原因: 如请求的API正常但APITimeoutError类型错误过多，请尝试调整模型配置中对应API Provider的timeout值\n" + f" 其它可能原因: 网络波动、DNS 故障、连接超时、防火墙限制或代理问题\n" + f" 剩余重试次数: {retry_remain}" + ) await asyncio.sleep(api_provider.retry_interval) except RespNotOkException as e: + original_error_info = self._get_original_error_info(e) + # 可重试的HTTP错误 if e.status_code == 429 or e.status_code >= 500: retry_remain -= 1 if retry_remain <= 0: - logger.error(f"模型 '{model_info.name}' 在遇到 {e.status_code} 错误并用尽重试次数后仍然失败。") + logger.error( + f"模型 '{model_info.name}' 在遇到 {e.status_code} 错误并用尽重试次数后仍然失败。{original_error_info}" + ) raise ModelAttemptFailed(f"模型 '{model_info.name}' 重试耗尽", original_exception=e) from e logger.warning( - f"模型 '{model_info.name}' 遇到可重试的HTTP错误: {str(e)}。剩余重试次数: {retry_remain}" + f"模型 '{model_info.name}' 遇到可重试的HTTP错误: {str(e)}{original_error_info}。剩余重试次数: {retry_remain}" ) await asyncio.sleep(api_provider.retry_interval) continue @@ -363,13 +415,15 @@ class LLMRequest: continue # 不可重试的HTTP错误 - logger.warning(f"模型 '{model_info.name}' 遇到不可重试的HTTP错误: {str(e)}") + logger.warning(f"模型 '{model_info.name}' 遇到不可重试的HTTP错误: {str(e)}{original_error_info}") raise ModelAttemptFailed(f"模型 '{model_info.name}' 遇到硬错误", original_exception=e) from e except Exception as e: logger.error(traceback.format_exc()) - logger.warning(f"模型 '{model_info.name}' 遇到未知的不可重试错误: {str(e)}") + original_error_info = self._get_original_error_info(e) + + logger.warning(f"模型 '{model_info.name}' 遇到未知的不可重试错误: {str(e)}{original_error_info}") raise ModelAttemptFailed(f"模型 '{model_info.name}' 遇到硬错误", original_exception=e) from e raise ModelAttemptFailed(f"模型 '{model_info.name}' 未被尝试，因为重试次数已配置为0或更少。") @@ -483,3 +537,12 @@ class LLMRequest: content = re.sub(r"(?:)?.*?", "", content, flags=re.DOTALL, count=1).strip() reasoning = match[1].strip() if match else "" return content, reasoning + + @staticmethod + def _get_original_error_info(e: Exception) -> str: + """获取原始错误信息""" + if e.__cause__: + original_error_type = type(e.__cause__).__name__ + original_error_msg = str(e.__cause__) + return f"\n 底层异常类型: {original_error_type}\n 底层异常信息: {original_error_msg}" + return "" diff --git a/src/main.py b/src/main.py index 09ead248..57950bf9 100644 --- a/src/main.py +++ b/src/main.py @@ -13,9 +13,9 @@ from src.config.config import global_config from src.chat.message_receive.bot import chat_bot 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 rich.traceback import install + # from src.api.main import start_api_server # 导入新的插件管理器 @@ -23,6 +23,7 @@ from src.plugin_system.core.plugin_manager import plugin_manager # 导入消息API和traceback模块 from src.common.message import get_global_api +from src.dream.dream_agent import start_dream_scheduler # 插件系统现在使用统一的插件加载器 @@ -43,30 +44,17 @@ class MainSystem: def _setup_webui_server(self): """设置独立的 WebUI 服务器""" - import os + from src.config.config import global_config - webui_enabled = os.getenv("WEBUI_ENABLED", "false").lower() == "true" - if not webui_enabled: + if not global_config.webui.enabled: logger.info("WebUI 已禁用") return - webui_mode = os.getenv("WEBUI_MODE", "production").lower() - try: from src.webui.webui_server import get_webui_server self.webui_server = get_webui_server() - - if webui_mode == "development": - logger.info("📝 WebUI 开发模式已启用") - logger.info("🌐 后端 API 将运行在 http://0.0.0.0:8001") - logger.info("💡 请手动启动前端开发服务器: cd MaiBot-Dashboard && bun dev") - logger.info("💡 前端将运行在 http://localhost:7999") - else: - logger.info("✅ WebUI 生产模式已启用") - logger.info(f"🌐 WebUI 将运行在 http://0.0.0.0:8001") - logger.info("💡 请确保已构建前端: cd MaiBot-Dashboard && bun run build") - + except Exception as e: logger.error(f"❌ 初始化 WebUI 服务器失败: {e}") @@ -106,7 +94,7 @@ class MainSystem: await async_task_manager.add_task(TelemetryHeartBeatTask()) # 添加记忆遗忘任务 - from src.chat.utils.memory_forget_task import MemoryForgetTask + from src.hippo_memorizer.memory_forget_task import MemoryForgetTask await async_task_manager.add_task(MemoryForgetTask()) @@ -124,11 +112,6 @@ class MainSystem: get_emoji_manager().initialize() 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()) @@ -156,9 +139,10 @@ class MainSystem: async def schedule_tasks(self): """调度定时任务""" - while True: + try: tasks = [ get_emoji_manager().start_periodic_check_register(), + start_dream_scheduler(), self.app.run(), self.server.run(), ] @@ -168,6 +152,9 @@ class MainSystem: tasks.append(self.webui_server.start()) await asyncio.gather(*tasks) + except asyncio.CancelledError: + logger.info("调度任务已取消") + raise # async def forget_memory_task(self): # """记忆遗忘任务""" diff --git a/src/memory_system/memory_retrieval.py b/src/memory_system/memory_retrieval.py index 7d129bbc..9aafb9ef 100644 --- a/src/memory_system/memory_retrieval.py +++ b/src/memory_system/memory_retrieval.py @@ -1,18 +1,17 @@ import time import json -import re -import random import asyncio -from typing import List, Dict, Any, Optional, Tuple +import re +from typing import List, Dict, Any, Optional, Tuple, Set from src.common.logger import get_logger from src.config.config import global_config, model_config from src.chat.utils.prompt_builder import Prompt, global_prompt_manager from src.plugin_system.apis import llm_api from src.common.database.database_model import ThinkingBack -from json_repair import repair_json from src.memory_system.retrieval_tools import get_tool_registry, init_all_tools -from src.memory_system.retrieval_tools.query_lpmm_knowledge import query_lpmm_knowledge +from src.memory_system.memory_utils import parse_questions_json from src.llm_models.payload_content.message import MessageBuilder, RoleType, Message +from src.bw_learner.jargon_explainer import match_jargon_from_text, retrieve_concepts_with_jargon logger = get_logger("memory_retrieval") @@ -63,39 +62,28 @@ def init_memory_retrieval_prompt(): 2. 是否有需要回忆的内容（比如"之前说过"、"上次"、"以前"等） 3. 是否有需要查找历史信息的问题 4. 是否有问题可以搜集信息帮助你聊天 -5. 对话中是否包含黑话、俚语、缩写等可能需要查询的概念 重要提示： - **每次只能提出一个问题**，选择最需要查询的关键问题 - 如果"最近已查询的问题和结果"中已经包含了类似的问题并得到了答案，请避免重复生成相同或相似的问题，不需要重复查询 - 如果之前已经查询过某个问题但未找到答案，可以尝试用不同的方式提问或更具体的问题 -如果你认为需要从记忆中检索信息来回答，请： -1. 识别对话中可能需要查询的概念（黑话/俚语/缩写/专有名词等关键词），放入"concepts"字段 -2. 根据上下文提出**一个**最关键的问题来帮助你回复目标消息，放入"questions"字段 +如果你认为需要从记忆中检索信息来回答，请根据上下文提出**一个**最关键的问题来帮助你回复目标消息，放入"questions"字段 问题格式示例： - "xxx在前几天干了什么" -- "xxx是什么" +- "xxx是什么，在什么时候提到过?" - "xxxx和xxx的关系是什么" - "xxx在某个时间点发生了什么" -输出格式示例（需要检索时）： +问题要说明前因后果和上下文，使其全面且精准 + +输出格式示例： ```json {{ - "concepts": ["AAA", "BBB", "CCC"], #需要检索的概念列表（字符串数组），如果不需要检索概念则输出空数组[] "questions": ["张三在前几天干了什么"] #问题数组（字符串数组），如果不需要检索记忆则输出空数组[]，如果需要检索则只输出包含一个问题的数组 }} ``` - -输出格式示例（不需要检索时）： -```json -{{ - "concepts": [], - "questions": [] -}} -``` - 请只输出JSON对象，不要输出其他内容： """, name="memory_retrieval_question_prompt", @@ -105,36 +93,20 @@ def init_memory_retrieval_prompt(): Prompt( """你的名字是{bot_name}。现在是{time_now}。 你正在参与聊天，你需要搜集信息来回答问题，帮助你参与聊天。 - -**重要限制：** -- 最大查询轮数：{max_iterations}轮（当前第{current_iteration}轮，剩余{remaining_iterations}轮） -- 必须尽快得出答案，避免不必要的查询 -- 思考要简短，直接切入要点 -- 必须严格使用检索到的信息回答问题，不要编造信息 - -当前问题：{question} +当前需要解答的问题：{question} 已收集的信息： {collected_info} -**执行步骤：** -**第一步：思考（Think）** -在思考中分析： -- 当前信息是否足够回答问题？ -- **如果信息足够且能找到明确答案**，在思考中直接给出答案，格式为：found_answer(answer="你的答案内容") -- **如果需要尝试搜集更多信息，进一步调用工具，进入第二步行动环节 -- **如果已有信息不足或无法找到答案**，在思考中给出：not_enough_info(reason="信息不足或无法找到答案的原因") - -**第二步：行动（Action）** -- 如果涉及过往事件，可以使用聊天记录查询工具查询过往事件 -- 如果涉及概念，可以用jargon查询，或根据关键词检索聊天记录 +**工具说明：** +- 如果涉及过往事件，或者查询某个过去可能提到过的概念，或者某段时间发生的事件。可以使用聊天记录查询工具查询过往事件 - 如果涉及人物，可以使用人物信息查询工具查询人物信息 -- 如果不确定查询类别，也可以使用lpmm知识库查询 -- 如果信息不足且需要继续查询，说明最需要查询什么，并输出为纯文本说明，然后调用相应工具查询（可并行调用多个工具） +- 如果没有可靠信息，且查询时间充足，或者不确定查询类别，也可以使用lpmm知识库查询，作为辅助信息 -**重要规则：** -- **只有在检索到明确、有关的信息并得出答案时，才使用found_answer** -- **如果信息不足、无法确定、找不到相关信息，必须使用not_enough_info，不要使用found_answer** -- 答案必须在思考中给出，格式为 found_answer(answer="...") 或 not_enough_info(reason="...") +**思考** +- 你可以对查询思路给出简短的思考：思考要简短，直接切入要点 +- 先思考当前信息是否足够回答问题 +- 如果信息不足，则需要使用tool查询信息，你必须给出使用什么工具进行查询 +- 如果当前已收集的信息足够或信息不足确定无法找到答案，你必须调用finish_search工具结束查询 """, name="memory_retrieval_react_prompt_head", ) @@ -148,14 +120,12 @@ def init_memory_retrieval_prompt(): 已收集的信息： {collected_info} -**执行步骤：** 分析： - 当前信息是否足够回答问题？ - **如果信息足够且能找到明确答案**，在思考中直接给出答案，格式为：found_answer(answer="你的答案内容") - **如果信息不足或无法找到答案**，在思考中给出：not_enough_info(reason="信息不足或无法找到答案的原因") **重要规则：** -- 你已经经过几轮查询，尝试了信息搜集，现在你需要总结信息，选择回答问题或判断问题无法回答 - 必须严格使用检索到的信息回答问题，不要编造信息 - 答案必须精简，不要过多解释 - **只有在检索到明确、具体的答案时，才使用found_answer** @@ -166,122 +136,73 @@ def init_memory_retrieval_prompt(): ) -def _parse_react_response(response: str) -> Optional[Dict[str, Any]]: - """解析ReAct Agent的响应 +def _log_conversation_messages( + conversation_messages: List[Message], + head_prompt: Optional[str] = None, + final_status: Optional[str] = None, +) -> None: + """输出对话消息列表的日志 Args: - response: LLM返回的响应 - - Returns: - Dict[str, Any]: 解析后的动作信息，如果解析失败返回None - 格式: {"thought": str, "actions": List[Dict[str, Any]]} - 每个action格式: {"action_type": str, "action_params": dict} + conversation_messages: 对话消息列表 + head_prompt: 第一条系统消息（head_prompt）的内容，可选 + final_status: 最终结果状态描述（例如：找到答案/未找到答案），可选 """ - try: - # 尝试提取JSON（可能包含在```json代码块中） - json_pattern = r"```json\s*(.*?)\s*```" - matches = re.findall(json_pattern, response, re.DOTALL) + if not global_config.debug.show_memory_prompt: + return - if matches: - json_str = matches[0] - else: - # 尝试直接解析整个响应 - json_str = response.strip() + log_lines: List[str] = [] - # 修复可能的JSON错误 - repaired_json = repair_json(json_str) + # 如果有head_prompt，先添加为第一条消息 + if head_prompt: + msg_info = "========================================\n[消息 1] 角色: System\n-----------------------------" + msg_info += f"\n{head_prompt}" + log_lines.append(msg_info) + start_idx = 2 + else: + start_idx = 1 - # 解析JSON - action_info = json.loads(repaired_json) + if not conversation_messages and not head_prompt: + return - if not isinstance(action_info, dict): - logger.warning(f"解析的JSON不是对象格式: {action_info}") - return None + for idx, msg in enumerate(conversation_messages, start_idx): + role_name = msg.role.value if hasattr(msg.role, "value") else str(msg.role) - # 确保actions字段存在且为列表 - if "actions" not in action_info: - logger.warning(f"响应中缺少actions字段: {action_info}") - return None + # 构建单条消息的日志信息 + # msg_info = f"\n========================================\n[消息 {idx}] 角色: {role_name} 内容类型: {content_type}\n-----------------------------" + msg_info = ( + f"\n========================================\n[消息 {idx}] 角色: {role_name}\n-----------------------------" + ) - if not isinstance(action_info["actions"], list): - logger.warning(f"actions字段不是数组格式: {action_info['actions']}") - return None + # if full_content: + # msg_info += f"\n{full_content}" + if msg.content: + msg_info += f"\n{msg.content}" - # 确保actions不为空 - if len(action_info["actions"]) == 0: - logger.warning("actions数组为空") - return None + if msg.tool_calls: + msg_info += f"\n 工具调用: {len(msg.tool_calls)}个" + for tool_call in msg.tool_calls: + msg_info += f"\n - {tool_call.func_name}: {json.dumps(tool_call.args, ensure_ascii=False)}" - return action_info + # if msg.tool_call_id: + # msg_info += f"\n 工具调用ID: {msg.tool_call_id}" - except Exception as e: - logger.error(f"解析ReAct响应失败: {e}, 响应内容: {response[:200]}...") - return None + log_lines.append(msg_info) - -async def _retrieve_concepts_with_jargon(concepts: List[str], chat_id: str) -> str: - """对概念列表进行jargon检索 - - Args: - concepts: 概念列表 - chat_id: 聊天ID - - Returns: - str: 检索结果字符串 - """ - if not concepts: - return "" - - from src.jargon.jargon_miner import search_jargon - - results = [] - for concept in concepts: - concept = concept.strip() - if not concept: - continue - - # 先尝试精确匹配 - jargon_results = search_jargon(keyword=concept, chat_id=chat_id, limit=10, case_sensitive=False, fuzzy=False) - - is_fuzzy_match = False - - # 如果精确匹配未找到，尝试模糊搜索 - if not jargon_results: - jargon_results = search_jargon(keyword=concept, chat_id=chat_id, limit=10, case_sensitive=False, fuzzy=True) - is_fuzzy_match = True - - if jargon_results: - # 找到结果 - if is_fuzzy_match: - # 模糊匹配 - output_parts = [f"未精确匹配到'{concept}'"] - for result in jargon_results: - found_content = result.get("content", "").strip() - meaning = result.get("meaning", "").strip() - if found_content and meaning: - output_parts.append(f"找到 '{found_content}' 的含义为：{meaning}") - results.append("，".join(output_parts)) - logger.info(f"在jargon库中找到匹配（模糊搜索）: {concept}，找到{len(jargon_results)}条结果") - else: - # 精确匹配 - output_parts = [] - for result in jargon_results: - meaning = result.get("meaning", "").strip() - if meaning: - output_parts.append(f"'{concept}' 为黑话或者网络简写，含义为：{meaning}") - results.append("；".join(output_parts) if len(output_parts) > 1 else output_parts[0]) - logger.info(f"在jargon库中找到匹配（精确匹配）: {concept}，找到{len(jargon_results)}条结果") - else: - # 未找到，不返回占位信息，只记录日志 - logger.info(f"在jargon库中未找到匹配: {concept}") - - if results: - return "【概念检索结果】\n" + "\n".join(results) + "\n" - return "" + total_count = len(conversation_messages) + (1 if head_prompt else 0) + log_text = f"消息列表 (共{total_count}条):{''.join(log_lines)}" + if final_status: + log_text += f"\n\n[最终结果] {final_status}" + logger.info(log_text) async def _react_agent_solve_question( - question: str, chat_id: str, max_iterations: int = 5, timeout: float = 30.0, initial_info: str = "" + question: str, + chat_id: str, + max_iterations: int = 5, + timeout: float = 30.0, + initial_info: str = "", + initial_jargon_concepts: Optional[List[str]] = None, ) -> Tuple[bool, str, List[Dict[str, Any]], bool]: """使用ReAct架构的Agent来解决问题 @@ -291,16 +212,26 @@ async def _react_agent_solve_question( max_iterations: 最大迭代次数 timeout: 超时时间（秒） initial_info: 初始信息（如概念检索结果），将作为collected_info的初始值 + initial_jargon_concepts: 预先已解析过的黑话列表，避免重复解释 Returns: Tuple[bool, str, List[Dict[str, Any]], bool]: (是否找到答案, 答案内容, 思考步骤列表, 是否超时) """ start_time = time.time() collected_info = initial_info if initial_info else "" + enable_jargon_detection = global_config.memory.enable_jargon_detection + seen_jargon_concepts: Set[str] = set() + if enable_jargon_detection and initial_jargon_concepts: + for concept in initial_jargon_concepts: + concept = (concept or "").strip() + if concept: + seen_jargon_concepts.add(concept) thinking_steps = [] is_timeout = False conversation_messages: List[Message] = [] + first_head_prompt: Optional[str] = None # 保存第一次使用的head_prompt（用于日志显示） + # 正常迭代：max_iterations 次（最终评估单独处理，不算在迭代中） for iteration in range(max_iterations): # 检查超时 if time.time() - start_time > timeout: @@ -320,146 +251,8 @@ async def _react_agent_solve_question( # 计算剩余迭代次数 current_iteration = iteration + 1 remaining_iterations = max_iterations - current_iteration - is_final_iteration = current_iteration >= max_iterations - if is_final_iteration: - # 最后一次迭代，使用最终prompt - tool_definitions = [] - logger.info( - f"ReAct Agent 第 {iteration + 1} 次迭代，问题: {question}|可用工具数量: 0（最后一次迭代，不提供工具调用）" - ) - - prompt = await global_prompt_manager.format_prompt( - "memory_retrieval_react_final_prompt", - bot_name=bot_name, - time_now=time_now, - question=question, - collected_info=collected_info if collected_info else "暂无信息", - current_iteration=current_iteration, - remaining_iterations=remaining_iterations, - max_iterations=max_iterations, - ) - - if global_config.debug.show_memory_prompt: - logger.info(f"ReAct Agent 第 {iteration + 1} 次Prompt: {prompt}") - success, response, reasoning_content, model_name, tool_calls = await llm_api.generate_with_model_with_tools( - prompt, - model_config=model_config.model_task_config.tool_use, - tool_options=tool_definitions, - request_type="memory.react", - ) - else: - # 非最终迭代，使用head_prompt - tool_definitions = tool_registry.get_tool_definitions() - logger.info( - f"ReAct Agent 第 {iteration + 1} 次迭代，问题: {question}|可用工具数量: {len(tool_definitions)}" - ) - - head_prompt = await global_prompt_manager.format_prompt( - "memory_retrieval_react_prompt_head", - bot_name=bot_name, - time_now=time_now, - question=question, - collected_info=collected_info if collected_info else "", - current_iteration=current_iteration, - remaining_iterations=remaining_iterations, - max_iterations=max_iterations, - ) - - def message_factory( - _client, - *, - _head_prompt: str = head_prompt, - _conversation_messages: List[Message] = conversation_messages, - ) -> List[Message]: - messages: List[Message] = [] - - system_builder = MessageBuilder() - system_builder.set_role(RoleType.System) - system_builder.add_text_content(_head_prompt) - messages.append(system_builder.build()) - - messages.extend(_conversation_messages) - - if global_config.debug.show_memory_prompt: - # 优化日志展示 - 合并所有消息到一条日志 - log_lines = [] - for idx, msg in enumerate(messages, 1): - role_name = msg.role.value if hasattr(msg.role, "value") else str(msg.role) - - # 处理内容 - 显示完整内容，不截断 - if isinstance(msg.content, str): - full_content = msg.content - content_type = "文本" - elif isinstance(msg.content, list): - text_parts = [item for item in msg.content if isinstance(item, str)] - image_count = len([item for item in msg.content if isinstance(item, tuple)]) - full_content = "".join(text_parts) if text_parts else "" - content_type = f"混合({len(text_parts)}段文本, {image_count}张图片)" - else: - full_content = str(msg.content) - content_type = "未知" - - # 构建单条消息的日志信息 - msg_info = f"\n[消息 {idx}] 角色: {role_name} 内容类型: {content_type}\n========================================" - - if full_content: - msg_info += f"\n{full_content}" - - if msg.tool_calls: - msg_info += f"\n 工具调用: {len(msg.tool_calls)}个" - for tool_call in msg.tool_calls: - msg_info += f"\n - {tool_call}" - - if msg.tool_call_id: - msg_info += f"\n 工具调用ID: {msg.tool_call_id}" - - log_lines.append(msg_info) - - # 合并所有消息为一条日志输出 - logger.info(f"消息列表 (共{len(messages)}条):{''.join(log_lines)}") - - return messages - - ( - success, - response, - reasoning_content, - model_name, - tool_calls, - ) = await llm_api.generate_with_model_with_tools_by_message_factory( - message_factory, - model_config=model_config.model_task_config.tool_use, - tool_options=tool_definitions, - request_type="memory.react", - ) - - logger.info( - f"ReAct Agent 第 {iteration + 1} 次迭代 模型: {model_name} ，调用工具数量: {len(tool_calls) if tool_calls else 0} ，调用工具响应: {response}" - ) - - if not success: - logger.error(f"ReAct Agent LLM调用失败: {response}") - break - - assistant_message: Optional[Message] = None - if tool_calls: - assistant_builder = MessageBuilder() - assistant_builder.set_role(RoleType.Assistant) - if response and response.strip(): - assistant_builder.add_text_content(response) - assistant_builder.set_tool_calls(tool_calls) - assistant_message = assistant_builder.build() - elif response and response.strip(): - assistant_builder = MessageBuilder() - assistant_builder.set_role(RoleType.Assistant) - assistant_builder.add_text_content(response) - assistant_message = assistant_builder.build() - - # 记录思考步骤 - step = {"iteration": iteration + 1, "thought": response, "actions": [], "observations": []} - - # 优先从思考内容中提取found_answer或not_enough_info + # 提取函数调用中参数的值，支持单引号和双引号 def extract_quoted_content(text, func_name, param_name): """从文本中提取函数调用中参数的值，支持单引号和双引号 @@ -517,45 +310,85 @@ async def _react_agent_solve_question( return None - # 从LLM的直接输出内容中提取found_answer或not_enough_info - found_answer_content = None - not_enough_info_reason = None + # 正常迭代：使用head_prompt决定调用哪些工具（包含finish_search工具） + tool_definitions = tool_registry.get_tool_definitions() + # tool_names = [tool_def["name"] for tool_def in tool_definitions] + # logger.debug(f"ReAct Agent 第 {iteration + 1} 次迭代，问题: {question}|可用工具: {', '.join(tool_names)} (共{len(tool_definitions)}个)") - # 只检查response（LLM的直接输出内容），不检查reasoning_content - if response: - found_answer_content = extract_quoted_content(response, "found_answer", "answer") - if not found_answer_content: - not_enough_info_reason = extract_quoted_content(response, "not_enough_info", "reason") + # head_prompt应该只构建一次，使用初始的collected_info，后续迭代都复用同一个 + if first_head_prompt is None: + # 第一次构建，使用初始的collected_info（即initial_info） + initial_collected_info = initial_info if initial_info else "" + first_head_prompt = await global_prompt_manager.format_prompt( + "memory_retrieval_react_prompt_head", + bot_name=bot_name, + time_now=time_now, + question=question, + collected_info=initial_collected_info, + current_iteration=current_iteration, + remaining_iterations=remaining_iterations, + max_iterations=max_iterations, + ) - # 如果从输出内容中找到了答案，直接返回 - if found_answer_content: - step["actions"].append({"action_type": "found_answer", "action_params": {"answer": found_answer_content}}) - step["observations"] = ["从LLM输出内容中检测到found_answer"] - thinking_steps.append(step) - logger.info( - f"ReAct Agent 第 {iteration + 1} 次迭代 从LLM输出内容中检测到found_answer: {found_answer_content[:100]}..." - ) - return True, found_answer_content, thinking_steps, False + # 后续迭代都复用第一次构建的head_prompt + head_prompt = first_head_prompt - if not_enough_info_reason: - step["actions"].append( - {"action_type": "not_enough_info", "action_params": {"reason": not_enough_info_reason}} - ) - step["observations"] = ["从LLM输出内容中检测到not_enough_info"] - thinking_steps.append(step) - logger.info( - f"ReAct Agent 第 {iteration + 1} 次迭代 从LLM输出内容中检测到not_enough_info: {not_enough_info_reason[:100]}..." - ) - return False, not_enough_info_reason, thinking_steps, False + def message_factory( + _client, + *, + _head_prompt: str = head_prompt, + _conversation_messages: List[Message] = conversation_messages, + ) -> List[Message]: + messages: List[Message] = [] - if is_final_iteration: - step["actions"].append( - {"action_type": "not_enough_info", "action_params": {"reason": "已到达最后一次迭代，无法找到答案"}} - ) - step["observations"] = ["已到达最后一次迭代，无法找到答案"] - thinking_steps.append(step) - logger.info(f"ReAct Agent 第 {iteration + 1} 次迭代 已到达最后一次迭代，无法找到答案") - return False, "已到达最后一次迭代，无法找到答案", thinking_steps, False + system_builder = MessageBuilder() + system_builder.set_role(RoleType.System) + system_builder.add_text_content(_head_prompt) + messages.append(system_builder.build()) + + messages.extend(_conversation_messages) + + return messages + + ( + success, + response, + reasoning_content, + model_name, + tool_calls, + ) = await llm_api.generate_with_model_with_tools_by_message_factory( + message_factory, + model_config=model_config.model_task_config.tool_use, + tool_options=tool_definitions, + request_type="memory.react", + ) + + # logger.info( + # f"ReAct Agent 第 {iteration + 1} 次迭代 模型: {model_name} ，调用工具数量: {len(tool_calls) if tool_calls else 0} ，调用工具响应: {response}" + # ) + + if not success: + logger.error(f"ReAct Agent LLM调用失败: {response}") + break + + # 注意：这里会检查finish_search工具调用，如果检测到finish_search工具，会根据found_answer参数决定返回答案或退出查询 + + assistant_message: Optional[Message] = None + if tool_calls: + assistant_builder = MessageBuilder() + assistant_builder.set_role(RoleType.Assistant) + if response and response.strip(): + assistant_builder.add_text_content(response) + assistant_builder.set_tool_calls(tool_calls) + assistant_message = assistant_builder.build() + elif response and response.strip(): + assistant_builder = MessageBuilder() + assistant_builder.set_role(RoleType.Assistant) + assistant_builder.add_text_content(response) + assistant_message = assistant_builder.build() + + # 记录思考步骤 + step = {"iteration": iteration + 1, "thought": response, "actions": [], "observations": []} if assistant_message: conversation_messages.append(assistant_message) @@ -568,43 +401,198 @@ async def _react_agent_solve_question( # 处理工具调用 if not tool_calls: - # 没有工具调用，说明LLM在思考中已经给出了答案（已在前面检查），或者需要继续查询 - # 如果思考中没有答案，说明需要继续查询或等待下一轮 + # 如果没有工具调用，检查响应文本中是否包含finish_search函数调用格式 if response and response.strip(): - # 如果响应不为空，记录思考过程，继续下一轮迭代 + # 尝试从文本中解析finish_search函数调用 + def parse_finish_search_from_text(text: str): + """从文本中解析finish_search函数调用，返回(found_answer, answer)元组，如果未找到则返回(None, None)""" + if not text: + return None, None + + # 查找finish_search函数调用位置（不区分大小写） + func_pattern = "finish_search" + text_lower = text.lower() + func_pos = text_lower.find(func_pattern) + if func_pos == -1: + return None, None + + # 查找函数调用的开始和结束位置 + # 从func_pos开始向后查找左括号 + start_pos = text.find("(", func_pos) + if start_pos == -1: + return None, None + + # 查找匹配的右括号（考虑嵌套） + paren_count = 0 + end_pos = start_pos + for i in range(start_pos, len(text)): + if text[i] == "(": + paren_count += 1 + elif text[i] == ")": + paren_count -= 1 + if paren_count == 0: + end_pos = i + break + else: + # 没有找到匹配的右括号 + return None, None + + # 提取函数参数部分 + params_text = text[start_pos + 1 : end_pos] + + # 解析found_answer参数（布尔值，可能是true/false/True/False） + found_answer = None + found_answer_patterns = [ + r"found_answer\s*=\s*true", + r"found_answer\s*=\s*True", + r"found_answer\s*=\s*false", + r"found_answer\s*=\s*False", + ] + for pattern in found_answer_patterns: + match = re.search(pattern, params_text, re.IGNORECASE) + if match: + found_answer = "true" in match.group(0).lower() + break + + # 解析answer参数（字符串，使用extract_quoted_content） + answer = extract_quoted_content(text, "finish_search", "answer") + + return found_answer, answer + + parsed_found_answer, parsed_answer = parse_finish_search_from_text(response) + + if parsed_found_answer is not None: + # 检测到finish_search函数调用格式 + if parsed_found_answer: + # 找到了答案 + if parsed_answer: + step["actions"].append( + { + "action_type": "finish_search", + "action_params": {"found_answer": True, "answer": parsed_answer}, + } + ) + step["observations"] = ["检测到finish_search文本格式调用，找到答案"] + thinking_steps.append(step) + logger.info( + f"ReAct Agent 第 {iteration + 1} 次迭代 通过finish_search文本格式找到关于问题{question}的答案: {parsed_answer}" + ) + + _log_conversation_messages( + conversation_messages, + head_prompt=first_head_prompt, + final_status=f"找到答案：{parsed_answer}", + ) + + return True, parsed_answer, thinking_steps, False + else: + # found_answer为True但没有提供answer，视为错误，继续迭代 + logger.warning( + f"ReAct Agent 第 {iteration + 1} 次迭代 finish_search文本格式found_answer为True但未提供answer" + ) + else: + # 未找到答案，直接退出查询 + step["actions"].append( + {"action_type": "finish_search", "action_params": {"found_answer": False}} + ) + step["observations"] = ["检测到finish_search文本格式调用，未找到答案"] + thinking_steps.append(step) + logger.info(f"ReAct Agent 第 {iteration + 1} 次迭代 通过finish_search文本格式判断未找到答案") + + _log_conversation_messages( + conversation_messages, + head_prompt=first_head_prompt, + final_status="未找到答案：通过finish_search文本格式判断未找到答案", + ) + + return False, "", thinking_steps, False + + # 如果没有检测到finish_search格式，记录思考过程，继续下一轮迭代 step["observations"] = [f"思考完成，但未调用工具。响应: {response}"] - logger.info(f"ReAct Agent 第 {iteration + 1} 次迭代 思考完成但未调用工具: {response[:100]}...") - # 继续下一轮迭代，让LLM有机会在思考中给出found_answer或继续查询 + logger.info(f"ReAct Agent 第 {iteration + 1} 次迭代 思考完成但未调用工具: {response}") collected_info += f"思考: {response}" - thinking_steps.append(step) - continue else: logger.warning(f"ReAct Agent 第 {iteration + 1} 次迭代 无工具调用且无响应") step["observations"] = ["无响应且无工具调用"] - thinking_steps.append(step) - break + thinking_steps.append(step) + continue # 处理工具调用 - tool_tasks = [] + # 首先检查是否有finish_search工具调用，如果有则立即返回，不再处理其他工具 + finish_search_found = None + finish_search_answer = None + for tool_call in tool_calls: + tool_name = tool_call.func_name + tool_args = tool_call.args or {} + if tool_name == "finish_search": + finish_search_found = tool_args.get("found_answer", False) + finish_search_answer = tool_args.get("answer", "") + + if finish_search_found: + # 找到了答案 + if finish_search_answer: + step["actions"].append( + { + "action_type": "finish_search", + "action_params": {"found_answer": True, "answer": finish_search_answer}, + } + ) + step["observations"] = ["检测到finish_search工具调用，找到答案"] + thinking_steps.append(step) + logger.info( + f"ReAct Agent 第 {iteration + 1} 次迭代 通过finish_search工具找到关于问题{question}的答案: {finish_search_answer}" + ) + + _log_conversation_messages( + conversation_messages, + head_prompt=first_head_prompt, + final_status=f"找到答案：{finish_search_answer}", + ) + + return True, finish_search_answer, thinking_steps, False + else: + # found_answer为True但没有提供answer，视为错误 + logger.warning( + f"ReAct Agent 第 {iteration + 1} 次迭代 finish_search工具found_answer为True但未提供answer" + ) + else: + # 未找到答案，直接退出查询 + step["actions"].append({"action_type": "finish_search", "action_params": {"found_answer": False}}) + step["observations"] = ["检测到finish_search工具调用，未找到答案"] + thinking_steps.append(step) + logger.info(f"ReAct Agent 第 {iteration + 1} 次迭代 通过finish_search工具判断未找到答案") + + _log_conversation_messages( + conversation_messages, + head_prompt=first_head_prompt, + final_status="未找到答案：通过finish_search工具判断未找到答案", + ) + + return False, "", thinking_steps, False + + # 如果没有finish_search工具调用，继续处理其他工具 + tool_tasks = [] for i, tool_call in enumerate(tool_calls): tool_name = tool_call.func_name tool_args = tool_call.args or {} - logger.info( + logger.debug( f"ReAct Agent 第 {iteration + 1} 次迭代 工具调用 {i + 1}/{len(tool_calls)}: {tool_name}({tool_args})" ) + # 跳过finish_search工具调用（已经在上面处理过了） + if tool_name == "finish_search": + continue + # 普通工具调用 tool = tool_registry.get_tool(tool_name) if tool: # 准备工具参数（需要添加chat_id如果工具需要） - tool_params = tool_args.copy() - - # 如果工具函数签名需要chat_id，添加它 import inspect sig = inspect.signature(tool.execute_func) + tool_params = tool_args.copy() if "chat_id" in sig.parameters: tool_params["chat_id"] = chat_id @@ -637,34 +625,231 @@ async def _react_agent_solve_question( logger.error(f"ReAct Agent 第 {iteration + 1} 次迭代 工具 {i + 1} 执行异常: {observation}") observation_text = observation if isinstance(observation, str) else str(observation) + stripped_observation = observation_text.strip() step["observations"].append(observation_text) collected_info += f"\n{observation_text}\n" - if observation_text.strip(): + if stripped_observation: + # 检查工具输出中是否有新的jargon，如果有则追加到工具结果中 + if enable_jargon_detection: + jargon_concepts = match_jargon_from_text(stripped_observation, chat_id) + if jargon_concepts: + new_concepts = [] + for concept in jargon_concepts: + normalized_concept = concept.strip() + if normalized_concept and normalized_concept not in seen_jargon_concepts: + new_concepts.append(normalized_concept) + seen_jargon_concepts.add(normalized_concept) + if new_concepts: + jargon_info = await retrieve_concepts_with_jargon(new_concepts, chat_id) + if jargon_info: + # 将jargon查询结果追加到工具结果中 + observation_text += f"\n\n{jargon_info}" + collected_info += f"\n{jargon_info}\n" + logger.info(f"工具输出触发黑话解析: {new_concepts}") + tool_builder = MessageBuilder() tool_builder.set_role(RoleType.Tool) tool_builder.add_text_content(observation_text) tool_builder.add_tool_call(tool_call_item.call_id) conversation_messages.append(tool_builder.build()) - # logger.info(f"ReAct Agent 第 {iteration + 1} 次迭代 工具 {i+1} 执行结果: {observation_text}") thinking_steps.append(step) - # 达到最大迭代次数或超时，但Agent没有明确返回found_answer - # 迭代超时应该直接视为not_enough_info，而不是使用已有信息 - # 只有Agent明确返回found_answer时，才认为找到了答案 - if collected_info: - logger.warning( - f"ReAct Agent达到最大迭代次数或超时，但未明确返回found_answer。已收集信息: {collected_info[:100]}..." - ) + # 正常迭代结束后，如果达到最大迭代次数或超时，执行最终评估 + # 最终评估单独处理，不算在迭代中 + should_do_final_evaluation = False if is_timeout: - logger.warning("ReAct Agent超时，直接视为not_enough_info") - else: - logger.warning("ReAct Agent达到最大迭代次数，直接视为not_enough_info") - return False, "未找到相关信息", thinking_steps, is_timeout + should_do_final_evaluation = True + logger.warning(f"ReAct Agent超时，已迭代{iteration + 1}次，进入最终评估") + elif iteration + 1 >= max_iterations: + should_do_final_evaluation = True + logger.info(f"ReAct Agent达到最大迭代次数（已迭代{iteration + 1}次），进入最终评估") + + if should_do_final_evaluation: + # 获取必要变量用于最终评估 + tool_registry = get_tool_registry() + bot_name = global_config.bot.nickname + time_now = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) + current_iteration = iteration + 1 + remaining_iterations = 0 + + # 提取函数调用中参数的值，支持单引号和双引号 + def extract_quoted_content(text, func_name, param_name): + """从文本中提取函数调用中参数的值，支持单引号和双引号 + + Args: + text: 要搜索的文本 + func_name: 函数名，如 'found_answer' + param_name: 参数名，如 'answer' + + Returns: + 提取的参数值，如果未找到则返回None + """ + if not text: + return None + + # 查找函数调用位置（不区分大小写） + func_pattern = func_name.lower() + text_lower = text.lower() + func_pos = text_lower.find(func_pattern) + if func_pos == -1: + return None + + # 查找参数名和等号 + param_pattern = f"{param_name}=" + param_pos = text_lower.find(param_pattern, func_pos) + if param_pos == -1: + return None + + # 跳过参数名、等号和空白 + start_pos = param_pos + len(param_pattern) + while start_pos < len(text) and text[start_pos] in " \t\n": + start_pos += 1 + + if start_pos >= len(text): + return None + + # 确定引号类型 + quote_char = text[start_pos] + if quote_char not in ['"', "'"]: + return None + + # 查找匹配的结束引号（考虑转义） + end_pos = start_pos + 1 + while end_pos < len(text): + if text[end_pos] == quote_char: + # 检查是否是转义的引号 + if end_pos > start_pos + 1 and text[end_pos - 1] == "\\": + end_pos += 1 + continue + # 找到匹配的引号 + content = text[start_pos + 1 : end_pos] + # 处理转义字符 + content = content.replace('\\"', '"').replace("\\'", "'").replace("\\\\", "\\") + return content + end_pos += 1 + + return None + + # 执行最终评估 + evaluation_prompt = await global_prompt_manager.format_prompt( + "memory_retrieval_react_final_prompt", + bot_name=bot_name, + time_now=time_now, + question=question, + collected_info=collected_info if collected_info else "暂无信息", + current_iteration=current_iteration, + remaining_iterations=remaining_iterations, + max_iterations=max_iterations, + ) + + ( + eval_success, + eval_response, + eval_reasoning_content, + eval_model_name, + eval_tool_calls, + ) = await llm_api.generate_with_model_with_tools( + evaluation_prompt, + model_config=model_config.model_task_config.tool_use, + tool_options=[], # 最终评估阶段不提供工具 + request_type="memory.react.final", + ) + + if not eval_success: + logger.error(f"ReAct Agent 最终评估阶段 LLM调用失败: {eval_response}") + _log_conversation_messages( + conversation_messages, + head_prompt=first_head_prompt, + final_status="未找到答案：最终评估阶段LLM调用失败", + ) + return False, "最终评估阶段LLM调用失败", thinking_steps, is_timeout + + if global_config.debug.show_memory_prompt: + logger.info(f"ReAct Agent 最终评估Prompt: {evaluation_prompt}") + logger.info(f"ReAct Agent 最终评估响应: {eval_response}") + + # 从最终评估响应中提取found_answer或not_enough_info + found_answer_content = None + not_enough_info_reason = None + + if eval_response: + found_answer_content = extract_quoted_content(eval_response, "found_answer", "answer") + if not found_answer_content: + not_enough_info_reason = extract_quoted_content(eval_response, "not_enough_info", "reason") + + # 如果找到答案，返回（找到答案时，无论是否超时，都视为成功完成） + if found_answer_content: + eval_step = { + "iteration": current_iteration, + "thought": f"[最终评估] {eval_response}", + "actions": [{"action_type": "found_answer", "action_params": {"answer": found_answer_content}}], + "observations": ["最终评估阶段检测到found_answer"], + } + thinking_steps.append(eval_step) + logger.info(f"ReAct Agent 最终评估阶段找到关于问题{question}的答案: {found_answer_content}") + + _log_conversation_messages( + conversation_messages, + head_prompt=first_head_prompt, + final_status=f"找到答案：{found_answer_content}", + ) + + return True, found_answer_content, thinking_steps, False + + # 如果评估为not_enough_info，返回空字符串（不返回任何信息） + if not_enough_info_reason: + eval_step = { + "iteration": current_iteration, + "thought": f"[最终评估] {eval_response}", + "actions": [{"action_type": "not_enough_info", "action_params": {"reason": not_enough_info_reason}}], + "observations": ["最终评估阶段检测到not_enough_info"], + } + thinking_steps.append(eval_step) + logger.info(f"ReAct Agent 最终评估阶段判断信息不足: {not_enough_info_reason}") + + _log_conversation_messages( + conversation_messages, + head_prompt=first_head_prompt, + final_status=f"未找到答案：{not_enough_info_reason}", + ) + + return False, "", thinking_steps, is_timeout + + # 如果没有明确判断，视为not_enough_info，返回空字符串（不返回任何信息） + eval_step = { + "iteration": current_iteration, + "thought": f"[最终评估] {eval_response}", + "actions": [ + {"action_type": "not_enough_info", "action_params": {"reason": "已到达最大迭代次数，无法找到答案"}} + ], + "observations": ["已到达最大迭代次数，无法找到答案"], + } + thinking_steps.append(eval_step) + logger.info("ReAct Agent 已到达最大迭代次数，无法找到答案") + + _log_conversation_messages( + conversation_messages, + head_prompt=first_head_prompt, + final_status="未找到答案：已到达最大迭代次数，无法找到答案", + ) + + return False, "", thinking_steps, is_timeout + + # 如果正常迭代过程中提前找到答案返回，不会到达这里 + # 如果正常迭代结束但没有触发最终评估（理论上不应该发生），直接返回 + logger.warning("ReAct Agent正常迭代结束，但未触发最终评估") + _log_conversation_messages( + conversation_messages, + head_prompt=first_head_prompt, + final_status="未找到答案：正常迭代结束", + ) + + return False, "", thinking_steps, is_timeout -def _get_recent_query_history(chat_id: str, time_window_seconds: float = 300.0) -> str: - """获取最近一段时间内的查询历史 +def _get_recent_query_history(chat_id: str, time_window_seconds: float = 600.0) -> str: + """获取最近一段时间内的查询历史（用于避免重复查询） Args: chat_id: 聊天ID @@ -714,169 +899,49 @@ def _get_recent_query_history(chat_id: str, time_window_seconds: float = 300.0) return "" -def _get_cached_memories(chat_id: str, time_window_seconds: float = 300.0) -> List[str]: - """获取最近一段时间内缓存的记忆（只返回找到答案的记录） +def _get_recent_found_answers(chat_id: str, time_window_seconds: float = 600.0) -> List[str]: + """获取最近一段时间内已找到答案的查询记录（用于返回给 replyer） Args: chat_id: 聊天ID - time_window_seconds: 时间窗口（秒），默认300秒（5分钟） + time_window_seconds: 时间窗口（秒），默认10分钟 Returns: - List[str]: 格式化的记忆列表，每个元素格式为 "问题：xxx\n答案：xxx" + List[str]: 格式化的答案列表，每个元素格式为 "问题：xxx\n答案：xxx" """ try: current_time = time.time() start_time = current_time - time_window_seconds - # 查询最近时间窗口内找到答案的记录，按更新时间倒序 + # 查询最近时间窗口内已找到答案的记录，按更新时间倒序 records = ( ThinkingBack.select() .where( (ThinkingBack.chat_id == chat_id) & (ThinkingBack.update_time >= start_time) & (ThinkingBack.found_answer == 1) + & (ThinkingBack.answer.is_null(False)) + & (ThinkingBack.answer != "") ) .order_by(ThinkingBack.update_time.desc()) - .limit(5) # 最多返回5条最近的记录 + .limit(3) # 最多返回5条最近的记录 ) if not records.exists(): return [] - cached_memories = [] + found_answers = [] for record in records: if record.answer: - cached_memories.append(f"问题：{record.question}\n答案：{record.answer}") + found_answers.append(f"问题：{record.question}\n答案：{record.answer}") - return cached_memories + return found_answers except Exception as e: - logger.error(f"获取缓存记忆失败: {e}") + logger.error(f"获取最近已找到答案的记录失败: {e}") return [] -def _query_thinking_back(chat_id: str, question: str) -> Optional[Tuple[bool, str]]: - """从thinking_back数据库中查询是否有现成的答案 - - Args: - chat_id: 聊天ID - question: 问题 - - Returns: - Optional[Tuple[bool, str]]: 如果找到记录，返回(found_answer, answer)，否则返回None - found_answer: 是否找到答案（True表示found_answer=1，False表示found_answer=0） - answer: 答案内容 - """ - try: - # 查询相同chat_id和问题的所有记录（包括found_answer为0和1的） - # 按更新时间倒序，获取最新的记录 - records = ( - ThinkingBack.select() - .where((ThinkingBack.chat_id == chat_id) & (ThinkingBack.question == question)) - .order_by(ThinkingBack.update_time.desc()) - .limit(1) - ) - - if records.exists(): - record = records.get() - found_answer = bool(record.found_answer) - answer = record.answer or "" - logger.info(f"在thinking_back中找到记录，问题: {question[:50]}...，found_answer: {found_answer}") - return found_answer, answer - - return None - - except Exception as e: - logger.error(f"查询thinking_back失败: {e}") - return None - - -async def _analyze_question_answer(question: str, answer: str, chat_id: str) -> None: - """异步分析问题和答案的类别，并存储到相应系统 - - Args: - question: 问题 - answer: 答案 - chat_id: 聊天ID - """ - try: - # 使用LLM分析类别 - analysis_prompt = f"""请分析以下问题和答案的类别： - -问题：{question} -答案：{answer} - -类别说明： -1. 人物信息：有关某个用户的个体信息（如某人的喜好、习惯、经历等） -2. 黑话：对特定概念、缩写词、谐音词、自创词的解释（如"yyds"、"社死"等） -3. 其他：除此之外的其他内容 - -请输出JSON格式： -{{ - "category": "人物信息" | "黑话" | "其他", - "jargon_keyword": "如果是黑话，提取关键词（如'yyds'），否则为空字符串", - "person_name": "如果是人物信息，提取人物名称，否则为空字符串", - "memory_content": "如果是人物信息，提取要存储的记忆内容（简短概括），否则为空字符串" -}} - -只输出JSON，不要输出其他内容：""" - - success, response, _, _ = await llm_api.generate_with_model( - analysis_prompt, - model_config=model_config.model_task_config.utils, - request_type="memory.analyze_qa", - ) - - if not success: - logger.error(f"分析问题和答案失败: {response}") - return - - # 解析JSON响应 - try: - json_pattern = r"```json\s*(.*?)\s*```" - matches = re.findall(json_pattern, response, re.DOTALL) - - if matches: - json_str = matches[0] - else: - json_str = response.strip() - - repaired_json = repair_json(json_str) - analysis_result = json.loads(repaired_json) - - category = analysis_result.get("category", "").strip() - - if category == "黑话": - # 处理黑话 - jargon_keyword = analysis_result.get("jargon_keyword", "").strip() - if jargon_keyword: - from src.jargon.jargon_miner import store_jargon_from_answer - - await store_jargon_from_answer(jargon_keyword, answer, chat_id) - else: - logger.warning(f"分析为黑话但未提取到关键词，问题: {question[:50]}...") - - elif category == "人物信息": - # 处理人物信息 - # person_name = analysis_result.get("person_name", "").strip() - # memory_content = analysis_result.get("memory_content", "").strip() - # if person_name and memory_content: - # from src.person_info.person_info import store_person_memory_from_answer - # await store_person_memory_from_answer(person_name, memory_content, chat_id) - # else: - # logger.warning(f"分析为人物信息但未提取到人物名称或记忆内容，问题: {question[:50]}...") - pass # 功能暂时禁用 - - else: - logger.info(f"问题和答案类别为'其他'，不进行存储，问题: {question[:50]}...") - - except Exception as e: - logger.error(f"解析分析结果失败: {e}, 响应: {response[:200]}...") - - except Exception as e: - logger.error(f"分析问题和答案时发生异常: {e}") - - def _store_thinking_back( chat_id: str, question: str, context: str, found_answer: bool, answer: str, thinking_steps: List[Dict[str, Any]] ) -> None: @@ -923,99 +988,70 @@ def _store_thinking_back( create_time=now, update_time=now, ) - logger.info(f"已创建思考过程到数据库，问题: {question[:50]}...") + # logger.info(f"已创建思考过程到数据库，问题: {question[:50]}...") except Exception as e: logger.error(f"存储思考过程失败: {e}") -async def _process_single_question(question: str, chat_id: str, context: str, initial_info: str = "") -> Optional[str]: - """处理单个问题的查询（包含缓存检查逻辑） +async def _process_single_question( + question: str, + chat_id: str, + context: str, + initial_info: str = "", + initial_jargon_concepts: Optional[List[str]] = None, + max_iterations: Optional[int] = None, +) -> Optional[str]: + """处理单个问题的查询 Args: question: 要查询的问题 chat_id: 聊天ID context: 上下文信息 initial_info: 初始信息（如概念检索结果），将传递给ReAct Agent + initial_jargon_concepts: 已经处理过的黑话概念列表，用于ReAct阶段的去重 Returns: Optional[str]: 如果找到答案，返回格式化的结果字符串，否则返回None """ - logger.info(f"开始处理问题: {question}") + # logger.info(f"开始处理问题: {question}") _cleanup_stale_not_found_thinking_back() question_initial_info = initial_info or "" - # 预先进行一次LPMM知识库查询，作为后续ReAct Agent的辅助信息 - if global_config.lpmm_knowledge.enable: - try: - lpmm_result = await query_lpmm_knowledge(question, limit=2) - if lpmm_result and lpmm_result.startswith("你从LPMM知识库中找到"): - if question_initial_info: - question_initial_info += "\n" - question_initial_info += f"【LPMM知识库预查询】\n{lpmm_result}" - logger.info(f"LPMM预查询命中，问题: {question[:50]}...") - else: - logger.info(f"LPMM预查询未命中或未找到信息，问题: {question[:50]}...") - except Exception as e: - logger.error(f"LPMM预查询失败，问题: {question[:50]}... 错误: {e}") + # 直接使用ReAct Agent查询（不再从thinking_back获取缓存） + # logger.info(f"使用ReAct Agent查询，问题: {question[:50]}...") - # 先检查thinking_back数据库中是否有现成答案 - cached_result = _query_thinking_back(chat_id, question) - should_requery = False + jargon_concepts_for_agent = initial_jargon_concepts if global_config.memory.enable_jargon_detection else None - if cached_result: - cached_found_answer, cached_answer = cached_result + # 如果未指定max_iterations，使用配置的默认值 + if max_iterations is None: + max_iterations = global_config.memory.max_agent_iterations - if cached_found_answer: # found_answer == 1 (True) - # found_answer == 1：20%概率重新查询 - if random.random() < 0.5: - should_requery = True - logger.info(f"found_answer=1，触发20%概率重新查询，问题: {question[:50]}...") + found_answer, answer, thinking_steps, is_timeout = await _react_agent_solve_question( + question=question, + chat_id=chat_id, + max_iterations=max_iterations, + timeout=global_config.memory.agent_timeout_seconds, + initial_info=question_initial_info, + initial_jargon_concepts=jargon_concepts_for_agent, + ) - if not should_requery and cached_answer: - logger.info(f"从thinking_back缓存中获取答案，问题: {question[:50]}...") - return f"问题：{question}\n答案：{cached_answer}" - elif not cached_answer: - should_requery = True - logger.info(f"found_answer=1 但缓存答案为空，重新查询，问题: {question[:50]}...") - else: - # found_answer == 0：不使用缓存，直接重新查询 - should_requery = True - logger.info(f"thinking_back存在但未找到答案，忽略缓存重新查询，问题: {question[:50]}...") - - # 如果没有缓存答案或需要重新查询，使用ReAct Agent查询 - if not cached_result or should_requery: - if should_requery: - logger.info(f"概率触发重新查询，使用ReAct Agent查询，问题: {question[:50]}...") - else: - logger.info(f"未找到缓存答案，使用ReAct Agent查询，问题: {question[:50]}...") - - found_answer, answer, thinking_steps, is_timeout = await _react_agent_solve_question( - question=question, + # 存储查询历史到数据库（超时时不存储） + if not is_timeout: + _store_thinking_back( chat_id=chat_id, - max_iterations=global_config.memory.max_agent_iterations, - timeout=120.0, - initial_info=question_initial_info, + question=question, + context=context, + found_answer=found_answer, + answer=answer, + thinking_steps=thinking_steps, ) + else: + logger.info(f"ReAct Agent超时，不存储到数据库，问题: {question[:50]}...") - # 存储到数据库（超时时不存储） - if not is_timeout: - _store_thinking_back( - chat_id=chat_id, - question=question, - context=context, - found_answer=found_answer, - answer=answer, - thinking_steps=thinking_steps, - ) - else: - logger.info(f"ReAct Agent超时，不存储到数据库，问题: {question[:50]}...") - - if found_answer and answer: - # 创建异步任务分析问题和答案 - asyncio.create_task(_analyze_question_answer(question, answer, chat_id)) - return f"问题：{question}\n答案：{answer}" + if found_answer and answer: + return f"问题：{question}\n答案：{answer}" return None @@ -1025,7 +1061,7 @@ async def build_memory_retrieval_prompt( sender: str, target: str, chat_stream, - tool_executor, + think_level: int = 1, ) -> str: """构建记忆检索提示 使用两段式查询：第一步生成问题，第二步使用ReAct Agent查询答案 @@ -1048,8 +1084,8 @@ async def build_memory_retrieval_prompt( bot_name = global_config.bot.nickname chat_id = chat_stream.stream_id - # 获取最近查询历史（最近1小时内的查询） - recent_query_history = _get_recent_query_history(chat_id, time_window_seconds=300.0) + # 获取最近查询历史（最近10分钟内的查询，用于避免重复查询） + recent_query_history = _get_recent_query_history(chat_id, time_window_seconds=600.0) if not recent_query_history: recent_query_history = "最近没有查询记录。" @@ -1072,57 +1108,68 @@ async def build_memory_retrieval_prompt( if global_config.debug.show_memory_prompt: logger.info(f"记忆检索问题生成提示词: {question_prompt}") - logger.info(f"记忆检索问题生成响应: {response}") + # logger.info(f"记忆检索问题生成响应: {response}") if not success: logger.error(f"LLM生成问题失败: {response}") return "" # 解析概念列表和问题列表 - concepts, questions = _parse_questions_json(response) - logger.info(f"解析到 {len(concepts)} 个概念: {concepts}") - logger.info(f"解析到 {len(questions)} 个问题: {questions}") + _, questions = parse_questions_json(response) + if questions: + logger.info(f"解析到 {len(questions)} 个问题: {questions}") - # 对概念进行jargon检索，作为初始信息 + enable_jargon_detection = global_config.memory.enable_jargon_detection + concepts: List[str] = [] + + if enable_jargon_detection: + # 使用匹配逻辑自动识别聊天中的黑话概念 + concepts = match_jargon_from_text(message, chat_id) + if concepts: + logger.info(f"黑话匹配命中 {len(concepts)} 个概念: {concepts}") + else: + logger.debug("黑话匹配未命中任何概念") + else: + logger.debug("已禁用记忆检索中的黑话识别") + + # 对匹配到的概念进行jargon检索，作为初始信息 initial_info = "" - if concepts: - logger.info(f"开始对 {len(concepts)} 个概念进行jargon检索") - concept_info = await _retrieve_concepts_with_jargon(concepts, chat_id) + if enable_jargon_detection and concepts: + concept_info = await retrieve_concepts_with_jargon(concepts, chat_id) if concept_info: initial_info += concept_info - logger.info(f"概念检索完成，结果: {concept_info[:200]}...") + logger.debug(f"概念检索完成，结果: {concept_info}") else: - logger.info("概念检索未找到任何结果") - - # 获取缓存的记忆（与question时使用相同的时间窗口和数量限制） - cached_memories = _get_cached_memories(chat_id, time_window_seconds=300.0) + logger.debug("概念检索未找到任何结果") if not questions: - logger.debug("模型认为不需要检索记忆或解析失败") - # 即使没有当次查询，也返回缓存的记忆和概念检索结果 - all_results = [] - if initial_info: - all_results.append(initial_info.strip()) - if cached_memories: - all_results.extend(cached_memories) + logger.debug("模型认为不需要检索记忆或解析失败，不返回任何查询结果") + end_time = time.time() + logger.info(f"无当次查询，不返回任何结果，耗时: {(end_time - start_time):.3f}秒") + return "" - if all_results: - retrieved_memory = "\n\n".join(all_results) - end_time = time.time() - logger.info(f"无当次查询，返回缓存记忆和概念检索结果，耗时: {(end_time - start_time):.3f}秒") - return f"你回忆起了以下信息：\n{retrieved_memory}\n如果与回复内容相关，可以参考这些回忆的信息。\n" - else: - return "" - - logger.info(f"解析到 {len(questions)} 个问题: {questions}") - - # 第二步：并行处理所有问题（使用配置的最大迭代次数/120秒超时） - max_iterations = global_config.memory.max_agent_iterations - logger.info(f"问题数量: {len(questions)}，设置最大迭代次数: {max_iterations}，超时时间: 120秒") + # 第二步：并行处理所有问题（使用配置的最大迭代次数和超时时间） + base_max_iterations = global_config.memory.max_agent_iterations + # 根据think_level调整迭代次数：think_level=1时不变，think_level=0时减半 + if think_level == 0: + max_iterations = max(1, base_max_iterations // 2) # 至少为1 + else: + max_iterations = base_max_iterations + timeout_seconds = global_config.memory.agent_timeout_seconds + logger.debug( + f"问题数量: {len(questions)}，think_level={think_level}，设置最大迭代次数: {max_iterations}（基础值: {base_max_iterations}），超时时间: {timeout_seconds}秒" + ) # 并行处理所有问题，将概念检索结果作为初始信息传递 question_tasks = [ - _process_single_question(question=question, chat_id=chat_id, context=message, initial_info=initial_info) + _process_single_question( + question=question, + chat_id=chat_id, + context=message, + initial_info=initial_info, + initial_jargon_concepts=concepts if enable_jargon_detection else None, + max_iterations=max_iterations, + ) for question in questions ] @@ -1130,90 +1177,53 @@ async def build_memory_retrieval_prompt( results = await asyncio.gather(*question_tasks, return_exceptions=True) # 收集所有有效结果 - all_results = [] - current_questions = set() # 用于去重，避免缓存和当次查询重复 + question_results: List[str] = [] for i, result in enumerate(results): if isinstance(result, Exception): logger.error(f"处理问题 '{questions[i]}' 时发生异常: {result}") elif result is not None: - all_results.append(result) - # 提取问题用于去重 - if result.startswith("问题："): - question = result.split("\n")[0].replace("问题：", "").strip() - current_questions.add(question) + question_results.append(result) - # 将缓存的记忆添加到结果中（排除当次查询已包含的问题，避免重复） - for cached_memory in cached_memories: - if cached_memory.startswith("问题："): - question = cached_memory.split("\n")[0].replace("问题：", "").strip() - # 只有当次查询中没有相同问题时，才添加缓存记忆 - if question not in current_questions: - all_results.append(cached_memory) - logger.debug(f"添加缓存记忆: {question[:50]}...") + # 获取最近10分钟内已找到答案的缓存记录 + cached_answers = _get_recent_found_answers(chat_id, time_window_seconds=600.0) + + # 合并当前查询结果和缓存答案（去重：如果当前查询的问题在缓存中已存在，优先使用当前结果） + all_results = [] + + # 先添加当前查询的结果 + current_questions = set() + for result in question_results: + # 提取问题（格式为 "问题：xxx\n答案：xxx"） + if result.startswith("问题："): + question_end = result.find("\n答案：") + if question_end != -1: + current_questions.add(result[4:question_end]) + all_results.append(result) + + # 添加缓存答案（排除当前查询中已存在的问题） + for cached_answer in cached_answers: + if cached_answer.startswith("问题："): + question_end = cached_answer.find("\n答案：") + if question_end != -1: + cached_question = cached_answer[4:question_end] + if cached_question not in current_questions: + all_results.append(cached_answer) end_time = time.time() if all_results: retrieved_memory = "\n\n".join(all_results) + current_count = len(question_results) + cached_count = len(all_results) - current_count logger.info( - f"记忆检索成功，耗时: {(end_time - start_time):.3f}秒，包含 {len(all_results)} 条记忆（含缓存）" + f"记忆检索成功，耗时: {(end_time - start_time):.3f}秒，" + f"当前查询 {current_count} 条记忆，缓存 {cached_count} 条记忆，共 {len(all_results)} 条记忆" ) return f"你回忆起了以下信息：\n{retrieved_memory}\n如果与回复内容相关，可以参考这些回忆的信息。\n" else: - logger.debug("所有问题均未找到答案，且无缓存记忆") + logger.debug("所有问题均未找到答案，且无缓存答案") return "" except Exception as e: logger.error(f"记忆检索时发生异常: {str(e)}") return "" - - -def _parse_questions_json(response: str) -> Tuple[List[str], List[str]]: - """解析问题JSON，返回概念列表和问题列表 - - Args: - response: LLM返回的响应 - - Returns: - Tuple[List[str], List[str]]: (概念列表, 问题列表) - """ - try: - # 尝试提取JSON（可能包含在```json代码块中） - json_pattern = r"```json\s*(.*?)\s*```" - matches = re.findall(json_pattern, response, re.DOTALL) - - if matches: - json_str = matches[0] - else: - # 尝试直接解析整个响应 - json_str = response.strip() - - # 修复可能的JSON错误 - repaired_json = repair_json(json_str) - - # 解析JSON - parsed = json.loads(repaired_json) - - # 只支持新格式：包含concepts和questions的对象 - if not isinstance(parsed, dict): - logger.warning(f"解析的JSON不是对象格式: {parsed}") - return [], [] - - concepts_raw = parsed.get("concepts", []) - questions_raw = parsed.get("questions", []) - - # 确保是列表 - if not isinstance(concepts_raw, list): - concepts_raw = [] - if not isinstance(questions_raw, list): - questions_raw = [] - - # 确保所有元素都是字符串 - concepts = [c for c in concepts_raw if isinstance(c, str) and c.strip()] - questions = [q for q in questions_raw if isinstance(q, str) and q.strip()] - - return concepts, questions - - except Exception as e: - logger.error(f"解析问题JSON失败: {e}, 响应内容: {response[:200]}...") - return [], [] diff --git a/src/memory_system/memory_utils.py b/src/memory_system/memory_utils.py index bff39f95..9886142c 100644 --- a/src/memory_system/memory_utils.py +++ b/src/memory_system/memory_utils.py @@ -8,7 +8,8 @@ import json import re from datetime import datetime from typing import Tuple -from difflib import SequenceMatcher +from typing import List +from json_repair import repair_json from src.common.logger import get_logger @@ -16,100 +17,55 @@ from src.common.logger import get_logger logger = get_logger("memory_utils") -def parse_md_json(json_text: str) -> list[str]: - """从Markdown格式的内容中提取JSON对象和推理内容""" - json_objects = [] - reasoning_content = "" - - # 使用正则表达式查找```json包裹的JSON内容 - json_pattern = r"```json\s*(.*?)\s*```" - matches = re.findall(json_pattern, json_text, re.DOTALL) - - # 提取JSON之前的内容作为推理文本 - if matches: - # 找到第一个```json的位置 - first_json_pos = json_text.find("```json") - if first_json_pos > 0: - reasoning_content = json_text[:first_json_pos].strip() - # 清理推理内容中的注释标记 - reasoning_content = re.sub(r"^//\s*", "", reasoning_content, flags=re.MULTILINE) - reasoning_content = reasoning_content.strip() - - for match in matches: - try: - # 清理可能的注释和格式问题 - json_str = re.sub(r"//.*?\n", "\n", match) # 移除单行注释 - json_str = re.sub(r"/\*.*?\*/", "", json_str, flags=re.DOTALL) # 移除多行注释 - if json_str := json_str.strip(): - json_obj = json.loads(json_str) - if isinstance(json_obj, dict): - json_objects.append(json_obj) - elif isinstance(json_obj, list): - for item in json_obj: - if isinstance(item, dict): - json_objects.append(item) - except Exception as e: - logger.warning(f"解析JSON块失败: {e}, 块内容: {match[:100]}...") - continue - - return json_objects, reasoning_content - - -def calculate_similarity(text1: str, text2: str) -> float: - """ - 计算两个文本的相似度 +def parse_questions_json(response: str) -> Tuple[List[str], List[str]]: + """解析问题JSON，返回概念列表和问题列表 Args: - text1: 第一个文本 - text2: 第二个文本 + response: LLM返回的响应 Returns: - float: 相似度分数 (0-1) + Tuple[List[str], List[str]]: (概念列表, 问题列表) """ try: - # 预处理文本 - text1 = preprocess_text(text1) - text2 = preprocess_text(text2) + # 尝试提取JSON（可能包含在```json代码块中） + json_pattern = r"```json\s*(.*?)\s*```" + matches = re.findall(json_pattern, response, re.DOTALL) - # 使用SequenceMatcher计算相似度 - similarity = SequenceMatcher(None, text1, text2).ratio() + if matches: + json_str = matches[0] + else: + # 尝试直接解析整个响应 + json_str = response.strip() - # 如果其中一个文本包含另一个，提高相似度 - if text1 in text2 or text2 in text1: - similarity = max(similarity, 0.8) + # 修复可能的JSON错误 + repaired_json = repair_json(json_str) - return similarity + # 解析JSON + parsed = json.loads(repaired_json) + + # 只支持新格式：包含concepts和questions的对象 + if not isinstance(parsed, dict): + logger.warning(f"解析的JSON不是对象格式: {parsed}") + return [], [] + + concepts_raw = parsed.get("concepts", []) + questions_raw = parsed.get("questions", []) + + # 确保是列表 + if not isinstance(concepts_raw, list): + concepts_raw = [] + if not isinstance(questions_raw, list): + questions_raw = [] + + # 确保所有元素都是字符串 + concepts = [c for c in concepts_raw if isinstance(c, str) and c.strip()] + questions = [q for q in questions_raw if isinstance(q, str) and q.strip()] + + return concepts, questions except Exception as e: - logger.error(f"计算相似度时出错: {e}") - return 0.0 - - -def preprocess_text(text: str) -> str: - """ - 预处理文本，提高匹配准确性 - - Args: - text: 原始文本 - - Returns: - str: 预处理后的文本 - """ - try: - # 转换为小写 - text = text.lower() - - # 移除标点符号和特殊字符 - text = re.sub(r"[^\w\s]", "", text) - - # 移除多余空格 - text = re.sub(r"\s+", " ", text).strip() - - return text - - except Exception as e: - logger.error(f"预处理文本时出错: {e}") - return text + logger.error(f"解析问题JSON失败: {e}, 响应内容: {response[:200]}...") + return [], [] def parse_datetime_to_timestamp(value: str) -> float: @@ -140,29 +96,3 @@ def parse_datetime_to_timestamp(value: str) -> float: except Exception as e: last_err = e raise ValueError(f"无法解析时间: {value} ({last_err})") - - -def parse_time_range(time_range: str) -> Tuple[float, float]: - """ - 解析时间范围字符串，返回开始和结束时间戳 - - Args: - time_range: 时间范围字符串，格式："YYYY-MM-DD HH:MM:SS - YYYY-MM-DD HH:MM:SS" - - Returns: - Tuple[float, float]: (开始时间戳, 结束时间戳) - """ - if " - " not in time_range: - raise ValueError(f"时间范围格式错误，应为 '开始时间 - 结束时间': {time_range}") - - parts = time_range.split(" - ", 1) - if len(parts) != 2: - raise ValueError(f"时间范围格式错误: {time_range}") - - start_str = parts[0].strip() - end_str = parts[1].strip() - - start_timestamp = parse_datetime_to_timestamp(start_str) - end_timestamp = parse_datetime_to_timestamp(end_str) - - return start_timestamp, end_timestamp diff --git a/src/memory_system/retrieval_tools/README.md b/src/memory_system/retrieval_tools/README.md deleted file mode 100644 index 50c36dbe..00000000 --- a/src/memory_system/retrieval_tools/README.md +++ /dev/null @@ -1,161 +0,0 @@ -# 记忆检索工具模块 - -这个模块提供了统一的工具注册和管理系统，用于记忆检索功能。 - -## 目录结构 - -``` -retrieval_tools/ -├── __init__.py # 模块导出 -├── tool_registry.py # 工具注册系统 -├── tool_utils.py # 工具函数库（共用函数） -├── query_jargon.py # 查询jargon工具 -├── query_chat_history.py # 查询聊天历史工具 -├── query_lpmm_knowledge.py # 查询LPMM知识库工具 -└── README.md # 本文件 -``` - -## 模块说明 - -### `tool_registry.py` -包含工具注册系统的核心类： -- `MemoryRetrievalTool`: 工具基类 -- `MemoryRetrievalToolRegistry`: 工具注册器 -- `register_memory_retrieval_tool()`: 便捷注册函数 -- `get_tool_registry()`: 获取注册器实例 - -### `tool_utils.py` -包含所有工具共用的工具函数： -- `parse_datetime_to_timestamp()`: 解析时间字符串为时间戳 -- `parse_time_range()`: 解析时间范围字符串 - -### 工具文件 -每个工具都有独立的文件： -- `query_jargon.py`: 根据关键词在jargon库中查询 -- `query_chat_history.py`: 根据时间或关键词在chat_history中查询（支持查询时间点事件、时间范围事件、关键词搜索） - -## 如何添加新工具 - -1. 创建新的工具文件，例如 `query_new_tool.py`： - -```python -""" -新工具 - 工具实现 -""" - -from src.common.logger import get_logger -from .tool_registry import register_memory_retrieval_tool -from .tool_utils import parse_datetime_to_timestamp # 如果需要使用工具函数 - -logger = get_logger("memory_retrieval_tools") - - -async def query_new_tool(param1: str, param2: str, chat_id: str) -> str: - """新工具的实现 - - Args: - param1: 参数1 - param2: 参数2 - chat_id: 聊天ID - - Returns: - str: 查询结果 - """ - try: - # 实现逻辑 - return "结果" - except Exception as e: - logger.error(f"新工具执行失败: {e}") - return f"查询失败: {str(e)}" - - -def register_tool(): - """注册工具""" - register_memory_retrieval_tool( - name="query_new_tool", - description="新工具的描述", - parameters=[ - { - "name": "param1", - "type": "string", - "description": "参数1的描述", - "required": True - }, - { - "name": "param2", - "type": "string", - "description": "参数2的描述", - "required": True - } - ], - execute_func=query_new_tool - ) -``` - -2. 在 `__init__.py` 中导入并注册新工具： - -```python -from .query_new_tool import register_tool as register_query_new_tool - -def init_all_tools(): - """初始化并注册所有记忆检索工具""" - register_query_jargon() - register_query_chat_history() - register_query_new_tool() # 添加新工具 -``` - -3. 工具会自动： - - 出现在 ReAct Agent 的 prompt 中 - - 在动作类型列表中可用 - - 被 ReAct Agent 自动调用 - -## 使用示例 - -```python -from src.memory_system.retrieval_tools import init_all_tools, get_tool_registry - -# 初始化所有工具 -init_all_tools() - -# 获取工具注册器 -registry = get_tool_registry() - -# 获取特定工具 -tool = registry.get_tool("query_chat_history") - -# 执行工具（查询时间点事件） -result = await tool.execute(time_point="2025-01-15 14:30:00", chat_id="chat123") - -# 或者查询关键词 -result = await tool.execute(keyword="小丑AI", chat_id="chat123") - -# 或者查询时间范围 -result = await tool.execute(time_range="2025-01-15 10:00:00 - 2025-01-15 20:00:00", chat_id="chat123") -``` - -## 现有工具说明 - -### query_jargon -根据关键词在jargon库中查询黑话/俚语/缩写的含义 -- 参数：`keyword` (必填) - 关键词 - -### query_chat_history -根据时间或关键词在chat_history中查询相关聊天记录。可以查询某个时间点发生了什么、某个时间范围内的事件，或根据关键词搜索消息 -- 参数： - - `keyword` (可选) - 关键词，用于搜索消息内容 - - `time_point` (可选) - 时间点，格式：YYYY-MM-DD HH:MM:SS，用于查询某个时间点附近发生了什么（与time_range二选一） - - `time_range` (可选) - 时间范围，格式：'YYYY-MM-DD HH:MM:SS - YYYY-MM-DD HH:MM:SS'（与time_point二选一） - -### query_lpmm_knowledge -从LPMM知识库中检索与关键词相关的知识内容 -- 参数： - - `query` (必填) - 查询的关键词或问题描述 - -## 注意事项 - -- 所有工具函数必须是异步函数（`async def`） -- 如果工具函数签名需要 `chat_id` 参数，系统会自动添加（通过函数签名检测） -- 工具参数定义中的 `required` 字段用于生成 prompt 描述 -- 工具执行失败时应返回错误信息字符串，而不是抛出异常 -- 共用函数放在 `tool_utils.py` 中，避免代码重复 - diff --git a/src/memory_system/retrieval_tools/__init__.py b/src/memory_system/retrieval_tools/__init__.py index 4b5c40c0..f30fd779 100644 --- a/src/memory_system/retrieval_tools/__init__.py +++ b/src/memory_system/retrieval_tools/__init__.py @@ -11,18 +11,18 @@ from .tool_registry import ( ) # 导入所有工具的注册函数 -from .query_jargon import register_tool as register_query_jargon from .query_chat_history import register_tool as register_query_chat_history from .query_lpmm_knowledge import register_tool as register_lpmm_knowledge from .query_person_info import register_tool as register_query_person_info +from .found_answer import register_tool as register_finish_search from src.config.config import global_config def init_all_tools(): """初始化并注册所有记忆检索工具""" - register_query_jargon() register_query_chat_history() register_query_person_info() + register_finish_search() # 注册finish_search工具 if global_config.lpmm_knowledge.lpmm_mode == "agent": register_lpmm_knowledge() diff --git a/src/memory_system/retrieval_tools/found_answer.py b/src/memory_system/retrieval_tools/found_answer.py new file mode 100644 index 00000000..bbed96b3 --- /dev/null +++ b/src/memory_system/retrieval_tools/found_answer.py @@ -0,0 +1,49 @@ +""" +finish_search工具 - 用于在记忆检索过程中结束查询 +""" + +from src.common.logger import get_logger +from .tool_registry import register_memory_retrieval_tool + +logger = get_logger("memory_retrieval_tools") + + +async def finish_search(found_answer: bool, answer: str = "") -> str: + """结束查询 + + Args: + found_answer: 是否找到了答案 + answer: 如果找到了答案，提供答案内容；如果未找到，可以为空 + + Returns: + str: 确认信息 + """ + if found_answer: + logger.info(f"找到答案: {answer}") + return f"已确认找到答案: {answer}" + else: + logger.info("未找到答案，结束查询") + return "未找到答案，查询结束" + + +def register_tool(): + """注册finish_search工具""" + register_memory_retrieval_tool( + name="finish_search", + description="当你决定结束查询时，调用此工具。如果找到了明确答案，设置found_answer为true并在answer中提供答案；如果未找到答案，设置found_answer为false。只有在检索到明确、具体的答案时才设置found_answer为true，不要编造信息。", + parameters=[ + { + "name": "found_answer", + "type": "boolean", + "description": "是否找到了答案", + "required": True, + }, + { + "name": "answer", + "type": "string", + "description": "如果found_answer为true，提供找到的答案内容，必须基于已收集的信息，不要编造；如果found_answer为false，可以为空", + "required": False, + }, + ], + execute_func=finish_search, + ) diff --git a/src/memory_system/retrieval_tools/query_chat_history.py b/src/memory_system/retrieval_tools/query_chat_history.py index 407bba05..351d0606 100644 --- a/src/memory_system/retrieval_tools/query_chat_history.py +++ b/src/memory_system/retrieval_tools/query_chat_history.py @@ -1,111 +1,111 @@ """ -根据时间或关键词在chat_history中查询 - 工具实现 +根据关键词或参与人在chat_history中查询记忆 - 工具实现 从ChatHistory表的聊天记录概述库中查询 """ import json from typing import Optional +from datetime import datetime + from src.common.logger import get_logger from src.common.database.database_model import ChatHistory from src.chat.utils.utils import parse_keywords_string +from src.config.config import global_config from .tool_registry import register_memory_retrieval_tool -from ..memory_utils import parse_datetime_to_timestamp, parse_time_range logger = get_logger("memory_retrieval_tools") -async def query_chat_history( - chat_id: str, keyword: Optional[str] = None, time_range: Optional[str] = None, fuzzy: bool = True -) -> str: - """根据时间或关键词在chat_history表中查询聊天记录概述 +async def search_chat_history(chat_id: str, keyword: Optional[str] = None, participant: Optional[str] = None) -> str: + """根据关键词或参与人查询记忆，返回匹配的记忆id、记忆标题theme和关键词keywords Args: chat_id: 聊天ID - keyword: 关键词（可选，支持多个关键词，可用空格、逗号等分隔） - time_range: 时间范围或时间点，格式： - - 时间范围："YYYY-MM-DD HH:MM:SS - YYYY-MM-DD HH:MM:SS" - - 时间点："YYYY-MM-DD HH:MM:SS"（查询包含该时间点的记录） - fuzzy: 是否使用模糊匹配模式（默认True） - - True: 模糊匹配，只要包含任意一个关键词即匹配（OR关系） - - False: 全匹配，必须包含所有关键词才匹配（AND关系） + keyword: 关键词（可选，支持多个关键词，可用空格、逗号等分隔。匹配规则：如果关键词数量<=2，必须全部匹配；如果关键词数量>2，允许n-1个关键词匹配） + participant: 参与人昵称（可选） Returns: - str: 查询结果 + str: 查询结果，包含记忆id、theme和keywords """ try: # 检查参数 - if not keyword and not time_range: - return "未指定查询参数（需要提供keyword或time_range之一）" + if not keyword and not participant: + return "未指定查询参数（需要提供keyword或participant之一）" # 构建查询条件 - query = ChatHistory.select().where(ChatHistory.chat_id == chat_id) + # 根据配置决定是否限制在当前 chat_id 内查询 + use_global_search = global_config.memory.global_memory - # 时间过滤条件 - if time_range: - # 判断是时间点还是时间范围 - if " - " in time_range: - # 时间范围：查询与时间范围有交集的记录 - start_timestamp, end_timestamp = parse_time_range(time_range) - # 交集条件：start_time < end_timestamp AND end_time > start_timestamp - time_filter = (ChatHistory.start_time < end_timestamp) & (ChatHistory.end_time > start_timestamp) - else: - # 时间点：查询包含该时间点的记录（start_time <= time_point <= end_time） - target_timestamp = parse_datetime_to_timestamp(time_range) - time_filter = (ChatHistory.start_time <= target_timestamp) & (ChatHistory.end_time >= target_timestamp) - query = query.where(time_filter) + if use_global_search: + # 全局查询所有聊天记录 + query = ChatHistory.select() + logger.debug( + f"search_chat_history 启用全局查询模式，忽略 chat_id 过滤，keyword={keyword}, participant={participant}" + ) + else: + # 仅在当前聊天流内查询 + query = ChatHistory.select().where(ChatHistory.chat_id == chat_id) # 执行查询 records = list(query.order_by(ChatHistory.start_time.desc()).limit(50)) - # 如果有关键词，进一步过滤 - if keyword: - # 解析多个关键词（支持空格、逗号等分隔符） - keywords_list = parse_keywords_string(keyword) - if not keywords_list: - keywords_list = [keyword.strip()] if keyword.strip() else [] + filtered_records = [] - # 转换为小写以便匹配 - keywords_lower = [kw.lower() for kw in keywords_list if kw.strip()] + for record in records: + participant_matched = True # 如果没有participant条件，默认为True + keyword_matched = True # 如果没有keyword条件，默认为True - if not keywords_lower: - return "关键词为空" - - filtered_records = [] - - for record in records: - # 在theme、keywords、summary、original_text中搜索 - theme = (record.theme or "").lower() - summary = (record.summary or "").lower() - original_text = (record.original_text or "").lower() - - # 解析record中的keywords JSON - record_keywords_list = [] - if record.keywords: + # 检查参与人匹配 + if participant: + participant_matched = False + participants_list = [] + if record.participants: try: - keywords_data = ( - json.loads(record.keywords) if isinstance(record.keywords, str) else record.keywords + participants_data = ( + json.loads(record.participants) + if isinstance(record.participants, str) + else record.participants ) - if isinstance(keywords_data, list): - record_keywords_list = [str(k).lower() for k in keywords_data] + if isinstance(participants_data, list): + participants_list = [str(p).lower() for p in participants_data] except (json.JSONDecodeError, TypeError, ValueError): pass - # 根据匹配模式检查关键词 - matched = False - if fuzzy: - # 模糊匹配：只要包含任意一个关键词即匹配（OR关系） - for kw in keywords_lower: - if ( - kw in theme - or kw in summary - or kw in original_text - or any(kw in k for k in record_keywords_list) - ): - matched = True - break - else: - # 全匹配：必须包含所有关键词才匹配（AND关系） - matched = True + participant_lower = participant.lower().strip() + if participant_lower and any(participant_lower in p for p in participants_list): + participant_matched = True + + # 检查关键词匹配 + if keyword: + keyword_matched = False + # 解析多个关键词（支持空格、逗号等分隔符） + keywords_list = parse_keywords_string(keyword) + if not keywords_list: + keywords_list = [keyword.strip()] if keyword.strip() else [] + + # 转换为小写以便匹配 + keywords_lower = [kw.lower() for kw in keywords_list if kw.strip()] + + if keywords_lower: + # 在theme、keywords、summary、original_text中搜索 + theme = (record.theme or "").lower() + summary = (record.summary or "").lower() + original_text = (record.original_text or "").lower() + + # 解析record中的keywords JSON + record_keywords_list = [] + if record.keywords: + try: + keywords_data = ( + json.loads(record.keywords) if isinstance(record.keywords, str) else record.keywords + ) + if isinstance(keywords_data, list): + record_keywords_list = [str(k).lower() for k in keywords_data] + except (json.JSONDecodeError, TypeError, ValueError): + pass + + # 有容错的全匹配：如果关键词数量>2，允许n-1个关键词匹配；否则必须全部匹配 + matched_count = 0 for kw in keywords_lower: kw_matched = ( kw in theme @@ -113,73 +113,112 @@ async def query_chat_history( or kw in original_text or any(kw in k for k in record_keywords_list) ) - if not kw_matched: - matched = False - break + if kw_matched: + matched_count += 1 - if matched: - filtered_records.append(record) + # 计算需要匹配的关键词数量 + total_keywords = len(keywords_lower) + if total_keywords > 2: + # 关键词数量>2，允许n-1个关键词匹配 + required_matches = total_keywords - 1 + else: + # 关键词数量<=2，必须全部匹配 + required_matches = total_keywords - if not filtered_records: - keywords_str = "、".join(keywords_list) - match_mode = "包含任意一个关键词" if fuzzy else "包含所有关键词" - if time_range: - return f"未找到{match_mode}'{keywords_str}'且在指定时间范围内的聊天记录概述" + keyword_matched = matched_count >= required_matches + + # 两者都匹配（如果同时有participant和keyword，需要两者都匹配；如果只有一个条件，只需要该条件匹配） + matched = participant_matched and keyword_matched + + if matched: + filtered_records.append(record) + + if not filtered_records: + if keyword and participant: + keywords_str = "、".join(parse_keywords_string(keyword) if keyword else []) + return f"未找到包含关键词'{keywords_str}'且参与人包含'{participant}'的聊天记录" + elif keyword: + keywords_str = "、".join(parse_keywords_string(keyword)) + keywords_list = parse_keywords_string(keyword) + if len(keywords_list) > 2: + required_count = len(keywords_list) - 1 + return ( + f"未找到包含至少{required_count}个关键词（共{len(keywords_list)}个）'{keywords_str}'的聊天记录" + ) else: - return f"未找到{match_mode}'{keywords_str}'的聊天记录概述" - - records = filtered_records - - # 如果没有记录（可能是时间范围查询但没有匹配的记录） - if not records: - if time_range: - return "未找到指定时间范围内的聊天记录概述" + return f"未找到包含所有关键词'{keywords_str}'的聊天记录" + elif participant: + return f"未找到参与人包含'{participant}'的聊天记录" else: - return "未找到相关聊天记录概述" + return "未找到相关聊天记录" - # 对即将返回的记录增加使用计数 - records_to_use = records[:3] - for record in records_to_use: - try: - ChatHistory.update(count=ChatHistory.count + 1).where(ChatHistory.id == record.id).execute() - record.count = (record.count or 0) + 1 - except Exception as update_error: - logger.error(f"更新聊天记录概述计数失败: {update_error}") + # 如果匹配结果超过20条，不返回具体记录，只返回提示和所有相关关键词 + if len(filtered_records) > 15: + # 统计所有记录上的关键词并去重 + all_keywords_set = set() + for record in filtered_records: + if record.keywords: + try: + keywords_data = ( + json.loads(record.keywords) if isinstance(record.keywords, str) else record.keywords + ) + if isinstance(keywords_data, list): + for k in keywords_data: + k_str = str(k).strip() + if k_str: + all_keywords_set.add(k_str) + except (json.JSONDecodeError, TypeError, ValueError): + continue - # 构建结果文本 + # xxx 使用用户原始查询词，优先 keyword，其次 participant，最后退化成“当前条件” + search_label = keyword or participant or "当前条件" + + if all_keywords_set: + keywords_str = "、".join(sorted(all_keywords_set)) + return ( + f"包含“{search_label}”的结果过多，请尝试更多关键词精确查找\n\n" + f'有关"{search_label}"的关键词：\n' + f"{keywords_str}" + ) + else: + return ( + f'包含“{search_label}”的结果过多，请尝试更多关键词精确查找\n\n有关"{search_label}"的关键词信息为空' + ) + + # 构建结果文本，返回id、theme和keywords（最多20条） results = [] - for record in records_to_use: # 最多返回3条记录 + for record in filtered_records[:20]: result_parts = [] + # 添加记忆ID + result_parts.append(f"记忆ID：{record.id}") + # 添加主题 if record.theme: result_parts.append(f"主题：{record.theme}") + else: + result_parts.append("主题：（无）") - # 添加时间范围 - from datetime import datetime - - start_str = datetime.fromtimestamp(record.start_time).strftime("%Y-%m-%d %H:%M:%S") - end_str = datetime.fromtimestamp(record.end_time).strftime("%Y-%m-%d %H:%M:%S") - result_parts.append(f"时间：{start_str} - {end_str}") - - # 添加概括（优先使用summary，如果没有则使用original_text的前200字符） - if record.summary: - result_parts.append(f"概括：{record.summary}") - elif record.original_text: - text_preview = record.original_text[:200] - if len(record.original_text) > 200: - text_preview += "..." - result_parts.append(f"内容：{text_preview}") + # 添加关键词 + if record.keywords: + try: + keywords_data = json.loads(record.keywords) if isinstance(record.keywords, str) else record.keywords + if isinstance(keywords_data, list) and keywords_data: + keywords_str = "、".join([str(k) for k in keywords_data]) + result_parts.append(f"关键词：{keywords_str}") + else: + result_parts.append("关键词：（无）") + except (json.JSONDecodeError, TypeError, ValueError): + result_parts.append("关键词：（无）") + else: + result_parts.append("关键词：（无）") results.append("\n".join(result_parts)) if not results: - return "未找到相关聊天记录概述" + return "未找到相关聊天记录" response_text = "\n\n---\n\n".join(results) - if len(records) > len(records_to_use): - omitted_count = len(records) - len(records_to_use) - response_text += f"\n\n(还有{omitted_count}条历史记录已省略)" return response_text except Exception as e: @@ -187,30 +226,145 @@ async def query_chat_history( return f"查询失败: {str(e)}" +async def get_chat_history_detail(chat_id: str, memory_ids: str) -> str: + """根据记忆ID，展示某条或某几条记忆的具体内容 + + Args: + chat_id: 聊天ID + memory_ids: 记忆ID，可以是单个ID（如"123"）或多个ID（用逗号分隔，如"1,2,3"） + + Returns: + str: 记忆的详细内容 + """ + try: + # 解析memory_ids + id_list = [] + # 尝试解析为逗号分隔的ID列表 + try: + id_list = [int(id_str.strip()) for id_str in memory_ids.split(",") if id_str.strip()] + except ValueError: + return f"无效的记忆ID格式: {memory_ids}，请使用数字ID，多个ID用逗号分隔（如：'123' 或 '123,456'）" + + if not id_list: + return "未提供有效的记忆ID" + + # 查询记录 + query = ChatHistory.select().where((ChatHistory.chat_id == chat_id) & (ChatHistory.id.in_(id_list))) + records = list(query.order_by(ChatHistory.start_time.desc())) + + if not records: + return f"未找到ID为{id_list}的记忆记录（可能ID不存在或不属于当前聊天）" + + # 对即将返回的记录增加使用计数 + for record in records: + try: + ChatHistory.update(count=ChatHistory.count + 1).where(ChatHistory.id == record.id).execute() + record.count = (record.count or 0) + 1 + except Exception as update_error: + logger.error(f"更新聊天记录概述计数失败: {update_error}") + + # 构建详细结果 + results = [] + for record in records: + result_parts = [] + + # 添加记忆ID + result_parts.append(f"记忆ID：{record.id}") + + # 添加主题 + if record.theme: + result_parts.append(f"主题：{record.theme}") + + # 添加时间范围 + start_str = datetime.fromtimestamp(record.start_time).strftime("%Y-%m-%d %H:%M:%S") + end_str = datetime.fromtimestamp(record.end_time).strftime("%Y-%m-%d %H:%M:%S") + result_parts.append(f"时间：{start_str} - {end_str}") + + # 添加参与人 + if record.participants: + try: + participants_data = ( + json.loads(record.participants) if isinstance(record.participants, str) else record.participants + ) + if isinstance(participants_data, list) and participants_data: + participants_str = "、".join([str(p) for p in participants_data]) + result_parts.append(f"参与人：{participants_str}") + except (json.JSONDecodeError, TypeError, ValueError): + pass + + # 添加关键词 + if record.keywords: + try: + keywords_data = json.loads(record.keywords) if isinstance(record.keywords, str) else record.keywords + if isinstance(keywords_data, list) and keywords_data: + keywords_str = "、".join([str(k) for k in keywords_data]) + result_parts.append(f"关键词：{keywords_str}") + except (json.JSONDecodeError, TypeError, ValueError): + pass + + # 添加概括 + if record.summary: + result_parts.append(f"概括：{record.summary}") + + # 添加关键信息点 + if record.key_point: + try: + key_point_data = ( + json.loads(record.key_point) if isinstance(record.key_point, str) else record.key_point + ) + if isinstance(key_point_data, list) and key_point_data: + key_point_str = "\n".join([f" - {str(kp)}" for kp in key_point_data]) + result_parts.append(f"关键信息点：\n{key_point_str}") + except (json.JSONDecodeError, TypeError, ValueError): + pass + + results.append("\n".join(result_parts)) + + if not results: + return "未找到相关记忆记录" + + response_text = "\n\n" + "=" * 50 + "\n\n".join(results) + return response_text + + except Exception as e: + logger.error(f"获取记忆详情失败: {e}") + return f"查询失败: {str(e)}" + + def register_tool(): """注册工具""" + # 注册工具1：搜索记忆 register_memory_retrieval_tool( - name="query_chat_history", - description="根据时间或关键词在聊天记录中查询。可以查询某个时间点发生了什么、某个时间范围内的事件，或根据关键词搜索消息概述。支持两种匹配模式：模糊匹配（默认，只要包含任意一个关键词即匹配）和全匹配（必须包含所有关键词才匹配）", + name="search_chat_history", + description="根据关键词或参与人查询记忆，返回匹配的记忆id、记忆标题theme和关键词keywords。用于快速搜索和定位相关记忆。匹配规则：如果关键词数量<=2，必须全部匹配；如果关键词数量>2，允许n-1个关键词匹配（容错匹配）。", parameters=[ { "name": "keyword", "type": "string", - "description": "关键词（可选，支持多个关键词，可用空格、逗号、斜杠等分隔，如：'麦麦 百度网盘' 或 '麦麦,百度网盘'。用于在主题、关键词、概括、原文中搜索）", + "description": "关键词（可选，支持多个关键词，可用空格、逗号、斜杠等分隔，如：'麦麦 百度网盘' 或 '麦麦,百度网盘'。用于在主题、关键词、概括、原文中搜索。匹配规则：如果关键词数量<=2，必须全部匹配；如果关键词数量>2，允许n-1个关键词匹配）", "required": False, }, { - "name": "time_range", + "name": "participant", "type": "string", - "description": "时间范围或时间点（可选）。格式：'YYYY-MM-DD HH:MM:SS - YYYY-MM-DD HH:MM:SS'（时间范围，查询与时间范围有交集的记录）或 'YYYY-MM-DD HH:MM:SS'（时间点，查询包含该时间点的记录）", - "required": False, - }, - { - "name": "fuzzy", - "type": "boolean", - "description": "是否使用模糊匹配模式（默认True）。True表示模糊匹配（只要包含任意一个关键词即匹配，OR关系），False表示全匹配（必须包含所有关键词才匹配，AND关系）", + "description": "参与人昵称（可选），用于查询包含该参与人的记忆", "required": False, }, ], - execute_func=query_chat_history, + execute_func=search_chat_history, + ) + + # 注册工具2：获取记忆详情 + register_memory_retrieval_tool( + name="get_chat_history_detail", + description="根据记忆ID，展示某条或某几条记忆的具体内容。包括主题、时间、参与人、关键词、概括和关键信息点等详细信息。需要先使用search_chat_history工具获取记忆ID。", + parameters=[ + { + "name": "memory_ids", + "type": "string", + "description": "记忆ID，可以是单个ID（如'123'）或多个ID（用逗号分隔，如'123,456,789'）", + "required": True, + }, + ], + execute_func=get_chat_history_detail, ) diff --git a/src/memory_system/retrieval_tools/query_jargon.py b/src/memory_system/retrieval_tools/query_jargon.py deleted file mode 100644 index 65050b85..00000000 --- a/src/memory_system/retrieval_tools/query_jargon.py +++ /dev/null @@ -1,76 +0,0 @@ -""" -根据关键词在jargon库中查询 - 工具实现 -""" - -from src.common.logger import get_logger -from src.jargon.jargon_miner import search_jargon -from .tool_registry import register_memory_retrieval_tool - -logger = get_logger("memory_retrieval_tools") - - -async def query_jargon(keyword: str, chat_id: str) -> str: - """根据关键词在jargon库中查询 - - Args: - keyword: 关键词（黑话/俚语/缩写） - chat_id: 聊天ID - - Returns: - str: 查询结果 - """ - try: - content = str(keyword).strip() - if not content: - return "关键词为空" - - # 先尝试精确匹配 - results = search_jargon(keyword=content, chat_id=chat_id, limit=10, case_sensitive=False, fuzzy=False) - - is_fuzzy_match = False - - # 如果精确匹配未找到，尝试模糊搜索 - if not results: - results = search_jargon(keyword=content, chat_id=chat_id, limit=10, case_sensitive=False, fuzzy=True) - is_fuzzy_match = True - - if results: - # 如果是模糊匹配，显示找到的实际jargon内容 - if is_fuzzy_match: - # 处理多个结果 - output_parts = [f"未精确匹配到'{content}'"] - for result in results: - found_content = result.get("content", "").strip() - meaning = result.get("meaning", "").strip() - if found_content and meaning: - output_parts.append(f"找到 '{found_content}' 的含义为：{meaning}") - output = "，".join(output_parts) - logger.info(f"在jargon库中找到匹配（当前会话或全局，模糊搜索）: {content}，找到{len(results)}条结果") - else: - # 精确匹配，可能有多条（相同content但不同chat_id的情况） - output_parts = [] - for result in results: - meaning = result.get("meaning", "").strip() - if meaning: - output_parts.append(f"'{content}' 为黑话或者网络简写，含义为：{meaning}") - output = "；".join(output_parts) if len(output_parts) > 1 else output_parts[0] - logger.info(f"在jargon库中找到匹配（当前会话或全局，精确匹配）: {content}，找到{len(results)}条结果") - return output - - # 未命中 - logger.info(f"在jargon库中未找到匹配（当前会话或全局，精确匹配和模糊搜索都未找到）: {content}") - return f"未在jargon库中找到'{content}'的解释" - - except Exception as e: - logger.error(f"查询jargon失败: {e}") - return f"查询失败: {str(e)}" - - -def register_tool(): - """注册工具""" - register_memory_retrieval_tool( - name="query_jargon", - description="根据关键词在jargon库中查询黑话/俚语/缩写的含义。支持大小写不敏感搜索，默认会先尝试精确匹配，如果找不到则自动使用模糊搜索。仅搜索当前会话或全局jargon。", - parameters=[{"name": "keyword", "type": "string", "description": "关键词（黑话/俚语/缩写）", "required": True}], - execute_func=query_jargon, - ) diff --git a/src/memory_system/retrieval_tools/query_person_info.py b/src/memory_system/retrieval_tools/query_person_info.py index bc192722..0f335cf1 100644 --- a/src/memory_system/retrieval_tools/query_person_info.py +++ b/src/memory_system/retrieval_tools/query_person_info.py @@ -12,6 +12,25 @@ from .tool_registry import register_memory_retrieval_tool logger = get_logger("memory_retrieval_tools") +def _calculate_similarity(query: str, target: str) -> float: + """计算查询词在目标字符串中的相似度比例 + + Args: + query: 查询词 + target: 目标字符串 + + Returns: + float: 相似度比例（0.0-1.0），查询词长度 / 目标字符串长度 + """ + if not query or not target: + return 0.0 + query_len = len(query) + target_len = len(target) + if target_len == 0: + return 0.0 + return query_len / target_len + + def _format_group_nick_names(group_nick_name_field) -> str: """格式化群昵称信息 @@ -81,11 +100,29 @@ async def query_person_info(person_name: str) -> str: if not records: return f"未找到模糊匹配'{person_name}'的用户信息" + # 根据相似度过滤结果：查询词在目标字符串中至少占50% + SIMILARITY_THRESHOLD = 0.5 + filtered_records = [] + for record in records: + if not record.person_name: + continue + # 精确匹配总是保留（相似度100%） + if record.person_name.strip() == person_name: + filtered_records.append(record) + else: + # 模糊匹配需要检查相似度 + similarity = _calculate_similarity(person_name, record.person_name.strip()) + if similarity >= SIMILARITY_THRESHOLD: + filtered_records.append(record) + + if not filtered_records: + return f"未找到相似度≥50%的匹配'{person_name}'的用户信息" + # 区分精确匹配和模糊匹配的结果 exact_matches = [] fuzzy_matches = [] - for record in records: + for record in filtered_records: # 检查是否是精确匹配 if record.person_name and record.person_name.strip() == person_name: exact_matches.append(record) @@ -248,7 +285,7 @@ async def query_person_info(person_name: str) -> str: response_text = "\n\n---\n\n".join(results) # 添加统计信息 - total_count = len(records) + total_count = len(filtered_records) exact_count = len(exact_matches) fuzzy_count = len(fuzzy_matches) diff --git a/src/mood/mood_manager.py b/src/mood/mood_manager.py deleted file mode 100644 index 7cc64801..00000000 --- a/src/mood/mood_manager.py +++ /dev/null @@ -1,230 +0,0 @@ -import time - -from src.common.logger import get_logger -from src.config.config import global_config, model_config -from src.chat.message_receive.chat_stream import get_chat_manager -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_by_timestamp_with_chat_inclusive -from src.llm_models.utils_model import LLMRequest -from src.manager.async_task_manager import AsyncTask, async_task_manager - - -logger = get_logger("mood") - - -def init_prompt(): - Prompt( - """ -{chat_talking_prompt} -以上是群里正在进行的聊天记录 - -{identity_block} -你先前的情绪状态是：{mood_state} -你的情绪特点是:{emotion_style} - -现在，请你根据先前的情绪状态和现在的聊天内容，总结推断你现在的情绪状态，用简短的词句来描述情绪状态 -请只输出新的情绪状态，不要输出其他内容： -""", - "get_mood_prompt", - ) - - Prompt( - """ -{chat_talking_prompt} -以上是群里最近的聊天记录 - -{identity_block} -你之前的情绪状态是：{mood_state} - -距离你上次关注群里消息已经过去了一段时间，你冷静了下来，请你输出一句话或几个词来描述你现在的情绪状态 -你的情绪特点是:{emotion_style} -请只输出新的情绪状态，不要输出其他内容： -""", - "regress_mood_prompt", - ) - - -class ChatMood: - def __init__(self, chat_id: str): - self.chat_id: str = chat_id - - chat_manager = get_chat_manager() - self.chat_stream = chat_manager.get_stream(self.chat_id) - - if not self.chat_stream: - raise ValueError(f"Chat stream for chat_id {chat_id} not found") - - self.log_prefix = f"[{self.chat_stream.group_info.group_name if self.chat_stream.group_info else self.chat_stream.user_info.user_nickname}]" - - self.mood_state: str = "感觉很平静" - - self.regression_count: int = 0 - - self.mood_model = LLMRequest(model_set=model_config.model_task_config.utils, request_type="mood") - - self.last_change_time: float = 0 - - async def get_mood(self) -> str: - self.regression_count = 0 - - current_time = time.time() - - 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=current_time, - limit=int(global_config.chat.max_context_size / 3), - 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 = "" - - identity_block = f"你的名字是{bot_name}{bot_nickname}" - - prompt = await global_prompt_manager.format_prompt( - "get_mood_prompt", - chat_talking_prompt=chat_talking_prompt, - identity_block=identity_block, - mood_state=self.mood_state, - emotion_style=global_config.mood.emotion_style, - ) - - response, (reasoning_content, _, _) = await self.mood_model.generate_response_async( - prompt=prompt, temperature=0.7 - ) - if global_config.debug.show_prompt: - logger.info(f"{self.log_prefix} prompt: {prompt}") - logger.info(f"{self.log_prefix} response: {response}") - logger.info(f"{self.log_prefix} reasoning_content: {reasoning_content}") - - logger.info(f"{self.log_prefix} 情绪状态更新为: {response}") - - self.mood_state = response - - self.last_change_time = current_time - - return response - - 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=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 = "" - - identity_block = f"你的名字是{bot_name}{bot_nickname}" - - prompt = await global_prompt_manager.format_prompt( - "regress_mood_prompt", - chat_talking_prompt=chat_talking_prompt, - identity_block=identity_block, - mood_state=self.mood_state, - emotion_style=global_config.mood.emotion_style, - ) - - response, (reasoning_content, _, _) = await self.mood_model.generate_response_async( - prompt=prompt, temperature=0.7 - ) - - if global_config.debug.show_prompt: - logger.info(f"{self.log_prefix} prompt: {prompt}") - logger.info(f"{self.log_prefix} response: {response}") - logger.info(f"{self.log_prefix} reasoning_content: {reasoning_content}") - - logger.info(f"{self.log_prefix} 情绪状态转变为: {response}") - - self.mood_state = response - - self.regression_count += 1 - - -class MoodRegressionTask(AsyncTask): - def __init__(self, mood_manager: "MoodManager"): - super().__init__(task_name="MoodRegressionTask", run_interval=45) - self.mood_manager = mood_manager - - async def run(self): - logger.debug("开始情绪回归任务...") - now = time.time() - for mood in self.mood_manager.mood_list: - if mood.last_change_time == 0: - continue - - if now - mood.last_change_time > 200: - if mood.regression_count >= 2: - continue - - logger.debug(f"{mood.log_prefix} 开始情绪回归, 第 {mood.regression_count + 1} 次") - await mood.regress_mood() - - -class MoodManager: - def __init__(self): - self.mood_list: list[ChatMood] = [] - """当前情绪状态""" - self.task_started: bool = False - - async def start(self): - """启动情绪回归后台任务""" - if self.task_started: - return - - task = MoodRegressionTask(self) - await async_task_manager.add_task(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.regression_count = 0 - return - self.mood_list.append(ChatMood(chat_id)) - - -init_prompt() - -mood_manager = MoodManager() -"""全局情绪管理器""" diff --git a/src/plugin_system/__init__.py b/src/plugin_system/__init__.py index a3561f0e..7e92a60d 100644 --- a/src/plugin_system/__init__.py +++ b/src/plugin_system/__init__.py @@ -11,6 +11,9 @@ from .base import ( BaseCommand, BaseTool, ConfigField, + ConfigSection, + ConfigLayout, + ConfigTab, ComponentType, ActionActivationType, ChatMode, @@ -116,6 +119,9 @@ __all__ = [ # 装饰器 "register_plugin", "ConfigField", + "ConfigSection", + "ConfigLayout", + "ConfigTab", # 工具函数 "ManifestValidator", "get_logger", diff --git a/src/plugin_system/apis/__init__.py b/src/plugin_system/apis/__init__.py index 730ee907..a872bfc7 100644 --- a/src/plugin_system/apis/__init__.py +++ b/src/plugin_system/apis/__init__.py @@ -19,7 +19,6 @@ from src.plugin_system.apis import ( send_api, tool_api, frequency_api, - mood_api, auto_talk_api, ) from .logging_api import get_logger @@ -42,6 +41,5 @@ __all__ = [ "register_plugin", "tool_api", "frequency_api", - "mood_api", "auto_talk_api", ] diff --git a/src/plugin_system/apis/emoji_api.py b/src/plugin_system/apis/emoji_api.py index e1661887..e4d6fcd7 100644 --- a/src/plugin_system/apis/emoji_api.py +++ b/src/plugin_system/apis/emoji_api.py @@ -104,7 +104,7 @@ async def get_random(count: Optional[int] = 1) -> List[Tuple[str, str, str]]: return [] if len(valid_emojis) < count: - logger.warning( + logger.debug( f"[EmojiAPI] 有效表情包数量 ({len(valid_emojis)}) 少于请求的数量 ({count})，将返回所有有效表情包" ) count = len(valid_emojis) diff --git a/src/plugin_system/apis/frequency_api.py b/src/plugin_system/apis/frequency_api.py index bc906186..9cde1d90 100644 --- a/src/plugin_system/apis/frequency_api.py +++ b/src/plugin_system/apis/frequency_api.py @@ -1,5 +1,5 @@ from src.common.logger import get_logger -from src.chat.frequency_control.frequency_control import frequency_control_manager +from src.chat.heart_flow.frequency_control import frequency_control_manager from src.config.config import global_config logger = get_logger("frequency_api") diff --git a/src/plugin_system/apis/generator_api.py b/src/plugin_system/apis/generator_api.py index 29d0b66d..4f7b63fc 100644 --- a/src/plugin_system/apis/generator_api.py +++ b/src/plugin_system/apis/generator_api.py @@ -81,10 +81,12 @@ async def generate_reply( chat_id: Optional[str] = None, action_data: Optional[Dict[str, Any]] = None, reply_message: Optional["DatabaseMessages"] = None, + think_level: int = 1, extra_info: str = "", reply_reason: str = "", available_actions: Optional[Dict[str, ActionInfo]] = None, chosen_actions: Optional[List["ActionPlannerInfo"]] = None, + unknown_words: Optional[List[str]] = None, enable_tool: bool = False, enable_splitter: bool = True, enable_chinese_typo: bool = True, @@ -103,6 +105,7 @@ async def generate_reply( reply_reason: 回复原因 available_actions: 可用动作 chosen_actions: 已选动作 + unknown_words: Planner 在 reply 动作中给出的未知词语列表，用于黑话检索 enable_tool: 是否启用工具调用 enable_splitter: 是否启用消息分割器 enable_chinese_typo: 是否启用错字生成器 @@ -122,11 +125,24 @@ async def generate_reply( logger.error("[GeneratorAPI] 无法获取回复器") return False, None - if not extra_info and action_data: - extra_info = action_data.get("extra_info", "") - - if not reply_reason and action_data: - reply_reason = action_data.get("reason", "") + if action_data: + if not extra_info: + extra_info = action_data.get("extra_info", "") + if not reply_reason: + reply_reason = action_data.get("reason", "") + # 仅在 reply 场景下使用的未知词语解析（Planner JSON 中下发） + if unknown_words is None: + uw = action_data.get("unknown_words") + if isinstance(uw, list): + # 只保留非空字符串 + cleaned: List[str] = [] + for item in uw: + if isinstance(item, str): + s = item.strip() + if s: + cleaned.append(s) + if cleaned: + unknown_words = cleaned # 调用回复器生成回复 success, llm_response = await replyer.generate_reply_with_context( @@ -136,6 +152,8 @@ async def generate_reply( enable_tool=enable_tool, reply_message=reply_message, reply_reason=reply_reason, + unknown_words=unknown_words, + think_level=think_level, from_plugin=from_plugin, stream_id=chat_stream.stream_id if chat_stream else chat_id, reply_time_point=reply_time_point, diff --git a/src/plugin_system/apis/llm_api.py b/src/plugin_system/apis/llm_api.py index a4e2dd30..fb4de48d 100644 --- a/src/plugin_system/apis/llm_api.py +++ b/src/plugin_system/apis/llm_api.py @@ -108,8 +108,8 @@ async def generate_with_model_with_tools( """ try: model_name_list = model_config.model_list - logger.info(f"[LLMAPI] 使用模型集合 {model_name_list} 生成内容") - logger.debug(f"[LLMAPI] 完整提示词: {prompt}") + logger.info(f"使用模型{model_name_list}生成内容") + logger.debug(f"完整提示词: {prompt}") llm_request = LLMRequest(model_set=model_config, request_type=request_type) @@ -147,7 +147,7 @@ async def generate_with_model_with_tools_by_message_factory( """ try: model_name_list = model_config.model_list - logger.info(f"[LLMAPI] 使用模型集合 {model_name_list} 生成内容（消息工厂）") + logger.info(f"使用模型 {model_name_list} 生成内容") 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 cfacd558..94ee9cbc 100644 --- a/src/plugin_system/apis/message_api.py +++ b/src/plugin_system/apis/message_api.py @@ -72,6 +72,7 @@ def get_messages_by_time_in_chat( limit_mode: str = "latest", filter_mai: bool = False, filter_command: bool = False, + filter_intercept_message_level: Optional[int] = None, ) -> List[DatabaseMessages]: """ 获取指定聊天中指定时间范围内的消息 @@ -110,6 +111,7 @@ def get_messages_by_time_in_chat( limit_mode=limit_mode, filter_bot=filter_mai, filter_command=filter_command, + filter_intercept_message_level=filter_intercept_message_level, ) @@ -121,6 +123,7 @@ def get_messages_by_time_in_chat_inclusive( limit_mode: str = "latest", filter_mai: bool = False, filter_command: bool = False, + filter_intercept_message_level: Optional[int] = None, ) -> List[DatabaseMessages]: """ 获取指定聊天中指定时间范围内的消息（包含边界） @@ -147,15 +150,19 @@ def get_messages_by_time_in_chat_inclusive( raise ValueError("chat_id 不能为空") if not isinstance(chat_id, str): raise ValueError("chat_id 必须是字符串类型") - if filter_mai: - return filter_mai_messages( - get_raw_msg_by_timestamp_with_chat_inclusive( - chat_id, start_time, end_time, limit, limit_mode, filter_command - ) - ) - return get_raw_msg_by_timestamp_with_chat_inclusive( - chat_id, start_time, end_time, limit, limit_mode, filter_command + messages = get_raw_msg_by_timestamp_with_chat_inclusive( + chat_id=chat_id, + timestamp_start=start_time, + timestamp_end=end_time, + limit=limit, + limit_mode=limit_mode, + filter_bot=filter_mai, + filter_command=filter_command, + filter_intercept_message_level=filter_intercept_message_level, ) + if filter_mai: + return filter_mai_messages(messages) + return messages def get_messages_by_time_in_chat_for_users( @@ -273,7 +280,11 @@ def get_messages_before_time(timestamp: float, limit: int = 0, filter_mai: bool def get_messages_before_time_in_chat( - chat_id: str, timestamp: float, limit: int = 0, filter_mai: bool = False + chat_id: str, + timestamp: float, + limit: int = 0, + filter_mai: bool = False, + filter_intercept_message_level: Optional[int] = None, ) -> List[DatabaseMessages]: """ 获取指定聊天中指定时间戳之前的消息 @@ -298,9 +309,15 @@ def get_messages_before_time_in_chat( raise ValueError("chat_id 不能为空") if not isinstance(chat_id, str): raise ValueError("chat_id 必须是字符串类型") + messages = get_raw_msg_before_timestamp_with_chat( + chat_id=chat_id, + timestamp=timestamp, + limit=limit, + filter_intercept_message_level=filter_intercept_message_level, + ) if filter_mai: - return filter_mai_messages(get_raw_msg_before_timestamp_with_chat(chat_id, timestamp, limit)) - return get_raw_msg_before_timestamp_with_chat(chat_id, timestamp, limit) + return filter_mai_messages(messages) + return messages def get_messages_before_time_for_users( diff --git a/src/plugin_system/apis/mood_api.py b/src/plugin_system/apis/mood_api.py deleted file mode 100644 index d5300e9f..00000000 --- a/src/plugin_system/apis/mood_api.py +++ /dev/null @@ -1,13 +0,0 @@ -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/base/__init__.py b/src/plugin_system/base/__init__.py index a8c320bf..9f930b5a 100644 --- a/src/plugin_system/base/__init__.py +++ b/src/plugin_system/base/__init__.py @@ -29,7 +29,7 @@ from .component_types import ( ForwardNode, ReplySetModel, ) -from .config_types import ConfigField +from .config_types import ConfigField, ConfigSection, ConfigLayout, ConfigTab __all__ = [ "BasePlugin", @@ -46,6 +46,9 @@ __all__ = [ "PluginInfo", "PythonDependency", "ConfigField", + "ConfigSection", + "ConfigLayout", + "ConfigTab", "EventHandlerInfo", "EventType", "BaseEventHandler", diff --git a/src/plugin_system/base/base_command.py b/src/plugin_system/base/base_command.py index 4b098869..0cfdb5d0 100644 --- a/src/plugin_system/base/base_command.py +++ b/src/plugin_system/base/base_command.py @@ -55,11 +55,11 @@ class BaseCommand(ABC): self.matched_groups = groups @abstractmethod - async def execute(self) -> Tuple[bool, Optional[str], bool]: + async def execute(self) -> Tuple[bool, Optional[str], int]: """执行Command的抽象方法，子类必须实现 Returns: - Tuple[bool, Optional[str], bool]: (是否执行成功, 可选的回复消息, 是否拦截消息 不进行 后续处理) + Tuple[bool, Optional[str], int]: (是否执行成功, 可选的回复消息, 拦截消息力度，0代表不拦截，1代表仅不触发回复，replyer可见，2代表不触发回复，replyer不可见) """ pass diff --git a/src/plugin_system/base/config_types.py b/src/plugin_system/base/config_types.py index 752b3345..18a98614 100644 --- a/src/plugin_system/base/config_types.py +++ b/src/plugin_system/base/config_types.py @@ -1,18 +1,273 @@ """ 插件系统配置类型定义 + +提供插件配置的类型定义，支持 WebUI 可视化配置编辑。 """ -from typing import Any, Optional, List +from typing import Any, Optional, List, Dict, Union from dataclasses import dataclass, field @dataclass class ConfigField: - """配置字段定义""" + """ + 配置字段定义 - type: type # 字段类型 + 用于定义插件配置项的元数据，支持类型验证、UI 渲染等功能。 + + 基础示例: + ConfigField(type=str, default="", description="API密钥") + + 完整示例: + ConfigField( + type=str, + default="", + description="API密钥", + input_type="password", + placeholder="请输入API密钥", + required=True, + hint="从服务商控制台获取", + order=1 + ) + """ + + # === 基础字段（必需） === + type: type # 字段类型: str, int, float, bool, list, dict default: Any # 默认值 - description: str # 字段描述 - example: Optional[str] = None # 示例值 + description: str # 字段描述（也用作默认标签） + + # === 验证相关 === + example: Optional[str] = None # 示例值（用于生成配置文件注释） required: bool = False # 是否必需 - choices: Optional[List[Any]] = field(default_factory=list) # 可选值列表 + choices: Optional[List[Any]] = field(default_factory=list) # 可选值列表（用于下拉选择） + min: Optional[float] = None # 最小值（数字类型） + max: Optional[float] = None # 最大值（数字类型） + step: Optional[float] = None # 步进值（数字类型） + pattern: Optional[str] = None # 正则验证（字符串类型） + max_length: Optional[int] = None # 最大长度（字符串类型） + + # === UI 显示控制 === + label: Optional[str] = None # 显示标签（默认使用 description） + placeholder: Optional[str] = None # 输入框占位符 + hint: Optional[str] = None # 字段下方的提示文字 + icon: Optional[str] = None # 字段图标名称 + hidden: bool = False # 是否在 UI 中隐藏 + disabled: bool = False # 是否禁用编辑 + order: int = 0 # 排序权重（数字越小越靠前） + + # === 输入控件类型 === + # 可选值: text, password, textarea, number, color, code, file, json + # 不指定时根据 type 和 choices 自动推断 + input_type: Optional[str] = None + + # === textarea 专用 === + rows: int = 3 # 文本域行数 + + # === 分组与布局 === + group: Optional[str] = None # 字段分组（在 section 内再细分） + + # === 条件显示 === + depends_on: Optional[str] = None # 依赖的字段路径，如 "section.field" + depends_value: Any = None # 依赖字段需要的值（当依赖字段等于此值时显示） + + # === 列表类型专用 === + item_type: Optional[str] = None # 数组元素类型: "string", "number", "object" + item_fields: Optional[Dict[str, Any]] = None # 当 item_type="object" 时，定义对象的字段结构 + min_items: Optional[int] = None # 数组最小元素数量 + max_items: Optional[int] = None # 数组最大元素数量 + + def get_ui_type(self) -> str: + """ + 获取 UI 控件类型 + + 如果指定了 input_type 则直接返回，否则根据 type 和 choices 自动推断。 + + Returns: + 控件类型字符串 + """ + if self.input_type: + return self.input_type + + # 根据 type 和 choices 自动推断 + if self.type is bool: + return "switch" + elif self.type in (int, float): + if self.min is not None and self.max is not None: + return "slider" + return "number" + elif self.type is str: + if self.choices: + return "select" + return "text" + elif self.type is list: + return "list" + elif self.type is dict: + return "json" + else: + return "text" + + def to_dict(self) -> Dict[str, Any]: + """ + 转换为可序列化的字典（用于 API 传输） + + Returns: + 包含所有配置信息的字典 + """ + return { + "type": self.type.__name__ if isinstance(self.type, type) else str(self.type), + "default": self.default, + "description": self.description, + "example": self.example, + "required": self.required, + "choices": self.choices if self.choices else None, + "min": self.min, + "max": self.max, + "step": self.step, + "pattern": self.pattern, + "max_length": self.max_length, + "label": self.label or self.description, + "placeholder": self.placeholder, + "hint": self.hint, + "icon": self.icon, + "hidden": self.hidden, + "disabled": self.disabled, + "order": self.order, + "input_type": self.input_type, + "ui_type": self.get_ui_type(), + "rows": self.rows, + "group": self.group, + "depends_on": self.depends_on, + "depends_value": self.depends_value, + "item_type": self.item_type, + "item_fields": self.item_fields, + "min_items": self.min_items, + "max_items": self.max_items, + } + + +@dataclass +class ConfigSection: + """ + 配置节定义 + + 用于描述配置文件中一个 section 的元数据。 + + 示例: + ConfigSection( + title="API配置", + description="外部API连接参数", + icon="cloud", + order=1 + ) + """ + + title: str # 显示标题 + description: Optional[str] = None # 详细描述 + icon: Optional[str] = None # 图标名称 + collapsed: bool = False # 默认是否折叠 + order: int = 0 # 排序权重 + + def to_dict(self) -> Dict[str, Any]: + """转换为可序列化的字典""" + return { + "title": self.title, + "description": self.description, + "icon": self.icon, + "collapsed": self.collapsed, + "order": self.order, + } + + +@dataclass +class ConfigTab: + """ + 配置标签页定义 + + 用于将多个 section 组织到一个标签页中。 + + 示例: + ConfigTab( + id="general", + title="通用设置", + icon="settings", + sections=["plugin", "api"] + ) + """ + + id: str # 标签页 ID + title: str # 显示标题 + sections: List[str] = field(default_factory=list) # 包含的 section 名称列表 + icon: Optional[str] = None # 图标名称 + order: int = 0 # 排序权重 + badge: Optional[str] = None # 角标文字（如 "Beta", "New"） + + def to_dict(self) -> Dict[str, Any]: + """转换为可序列化的字典""" + return { + "id": self.id, + "title": self.title, + "sections": self.sections, + "icon": self.icon, + "order": self.order, + "badge": self.badge, + } + + +@dataclass +class ConfigLayout: + """ + 配置页面布局定义 + + 用于定义插件配置页面的整体布局结构。 + + 布局类型: + - "auto": 自动布局，sections 作为折叠面板显示 + - "tabs": 标签页布局 + - "pages": 分页布局（左侧导航 + 右侧内容） + + 简单示例（标签页布局）: + ConfigLayout( + type="tabs", + tabs=[ + ConfigTab(id="basic", title="基础", sections=["plugin", "api"]), + ConfigTab(id="advanced", title="高级", sections=["debug"]), + ] + ) + """ + + type: str = "auto" # 布局类型: auto, tabs, pages + tabs: List[ConfigTab] = field(default_factory=list) # 标签页列表 + + def to_dict(self) -> Dict[str, Any]: + """转换为可序列化的字典""" + return { + "type": self.type, + "tabs": [tab.to_dict() for tab in self.tabs], + } + + +def section_meta( + title: str, description: Optional[str] = None, icon: Optional[str] = None, collapsed: bool = False, order: int = 0 +) -> Union[str, ConfigSection]: + """ + 便捷函数：创建 section 元数据 + + 可以在 config_section_descriptions 中使用，提供比纯字符串更丰富的信息。 + + Args: + title: 显示标题 + description: 详细描述 + icon: 图标名称 + collapsed: 默认是否折叠 + order: 排序权重 + + Returns: + ConfigSection 实例 + + 示例: + config_section_descriptions = { + "api": section_meta("API配置", icon="cloud", order=1), + "debug": section_meta("调试设置", collapsed=True, order=99), + } + """ + return ConfigSection(title=title, description=description, icon=icon, collapsed=collapsed, order=order) diff --git a/src/plugin_system/base/plugin_base.py b/src/plugin_system/base/plugin_base.py index 0b7f15d1..f21c2a40 100644 --- a/src/plugin_system/base/plugin_base.py +++ b/src/plugin_system/base/plugin_base.py @@ -12,7 +12,11 @@ from src.plugin_system.base.component_types import ( PluginInfo, PythonDependency, ) -from src.plugin_system.base.config_types import ConfigField +from src.plugin_system.base.config_types import ( + ConfigField, + ConfigSection, + ConfigLayout, +) from src.plugin_system.utils.manifest_utils import ManifestValidator logger = get_logger("plugin_base") @@ -60,7 +64,10 @@ class PluginBase(ABC): def config_schema(self) -> Dict[str, Union[Dict[str, ConfigField], str]]: return {} - config_section_descriptions: Dict[str, str] = {} + config_section_descriptions: Dict[str, Union[str, ConfigSection]] = {} + + # 布局配置（可选，不定义则使用自动布局） + config_layout: ConfigLayout = None def __init__(self, plugin_dir: str): """初始化插件 @@ -205,6 +212,22 @@ class PluginBase(ABC): return value + def _format_toml_value(self, value: Any) -> str: + """将Python值格式化为合法的TOML字符串""" + if isinstance(value, str): + return json.dumps(value, ensure_ascii=False) + if isinstance(value, bool): + return str(value).lower() + if isinstance(value, (int, float)): + return str(value) + if isinstance(value, list): + inner = ", ".join(self._format_toml_value(item) for item in value) + return f"[{inner}]" + if isinstance(value, dict): + items = [f"{k} = {self._format_toml_value(v)}" for k, v in value.items()] + return "{ " + ", ".join(items) + " }" + return json.dumps(value, ensure_ascii=False) + def _generate_and_save_default_config(self, config_file_path: str): """根据插件的Schema生成并保存默认配置文件""" if not self.config_schema: @@ -244,12 +267,7 @@ class PluginBase(ABC): # 添加字段值 value = field.default - if isinstance(value, str): - toml_str += f'{field_name} = "{value}"\n' - elif isinstance(value, bool): - toml_str += f"{field_name} = {str(value).lower()}\n" - else: - toml_str += f"{field_name} = {value}\n" + toml_str += f"{field_name} = {self._format_toml_value(value)}\n" toml_str += "\n" toml_str += "\n" @@ -422,19 +440,7 @@ class PluginBase(ABC): # 添加字段值（使用迁移后的值） value = section_data.get(field_name, field.default) - if isinstance(value, str): - toml_str += f'{field_name} = "{value}"\n' - elif isinstance(value, bool): - toml_str += f"{field_name} = {str(value).lower()}\n" - elif isinstance(value, list): - # 格式化列表 - if all(isinstance(item, str) for item in value): - formatted_list = "[" + ", ".join(f'"{item}"' for item in value) + "]" - else: - formatted_list = str(value) - toml_str += f"{field_name} = {formatted_list}\n" - else: - toml_str += f"{field_name} = {value}\n" + toml_str += f"{field_name} = {self._format_toml_value(value)}\n" toml_str += "\n" toml_str += "\n" @@ -564,6 +570,93 @@ class PluginBase(ABC): return current + def get_webui_config_schema(self) -> Dict[str, Any]: + """ + 获取 WebUI 配置 Schema + + 返回完整的配置 schema，包含： + - 插件基本信息 + - 所有 section 及其字段定义 + - 布局配置 + + 用于 WebUI 动态生成配置表单。 + + Returns: + Dict: 完整的配置 schema + """ + schema = { + "plugin_id": self.plugin_name, + "plugin_info": { + "name": self.display_name, + "version": self.plugin_version, + "description": self.plugin_description, + "author": self.plugin_author, + }, + "sections": {}, + "layout": None, + } + + # 处理 sections + for section_name, fields in self.config_schema.items(): + if not isinstance(fields, dict): + continue + + section_data = { + "name": section_name, + "title": section_name, + "description": None, + "icon": None, + "collapsed": False, + "order": 0, + "fields": {}, + } + + # 获取 section 元数据 + section_meta = self.config_section_descriptions.get(section_name) + if section_meta: + if isinstance(section_meta, str): + section_data["title"] = section_meta + elif isinstance(section_meta, ConfigSection): + section_data["title"] = section_meta.title + section_data["description"] = section_meta.description + section_data["icon"] = section_meta.icon + section_data["collapsed"] = section_meta.collapsed + section_data["order"] = section_meta.order + elif isinstance(section_meta, dict): + section_data.update(section_meta) + + # 处理字段 + for field_name, field_def in fields.items(): + if isinstance(field_def, ConfigField): + field_data = field_def.to_dict() + field_data["name"] = field_name + section_data["fields"][field_name] = field_data + + schema["sections"][section_name] = section_data + + # 处理布局 + if self.config_layout: + schema["layout"] = self.config_layout.to_dict() + else: + # 自动布局：按 section order 排序 + schema["layout"] = { + "type": "auto", + "tabs": [], + } + + return schema + + def get_current_config_values(self) -> Dict[str, Any]: + """ + 获取当前配置值 + + 返回插件当前的配置值（已从配置文件加载）。 + + Returns: + Dict: 当前配置值 + """ + return self.config.copy() + @abstractmethod def register_plugin(self) -> bool: """ diff --git a/src/plugin_system/core/tool_use.py b/src/plugin_system/core/tool_use.py index 915ed7aa..6d60ee77 100644 --- a/src/plugin_system/core/tool_use.py +++ b/src/plugin_system/core/tool_use.py @@ -95,7 +95,7 @@ class ToolExecutor: # 如果没有可用工具，直接返回空内容 if not tools: - logger.info(f"{self.log_prefix}没有可用工具，直接返回空内容") + logger.debug(f"{self.log_prefix}没有可用工具，直接返回空内容") if return_details: return [], [], "" else: diff --git a/src/plugins/built_in/emoji_plugin/emoji.py b/src/plugins/built_in/emoji_plugin/emoji.py index 3783886a..8599620a 100644 --- a/src/plugins/built_in/emoji_plugin/emoji.py +++ b/src/plugins/built_in/emoji_plugin/emoji.py @@ -47,7 +47,7 @@ class EmojiAction(BaseAction): try: # 1. 获取发送表情的原因 # reason = self.action_data.get("reason", "表达当前情绪") - reason = self.reasoning + reason = self.action_reasoning # 2. 随机获取20个表情包 sampled_emojis = await emoji_api.get_random(30) diff --git a/src/plugins/built_in/knowledge/lpmm_get_knowledge.py b/src/plugins/built_in/knowledge/lpmm_get_knowledge.py index 174bef1c..bb627e5e 100644 --- a/src/plugins/built_in/knowledge/lpmm_get_knowledge.py +++ b/src/plugins/built_in/knowledge/lpmm_get_knowledge.py @@ -15,7 +15,7 @@ class SearchKnowledgeFromLPMMTool(BaseTool): description = "从知识库中搜索相关信息，如果你需要知识，就使用这个工具" parameters = [ ("query", ToolParamType.STRING, "搜索查询关键词", True, None), - ("limit", ToolParamType.INTEGER, "希望返回的相关知识条数，默认5", False, 5), + ("limit", ToolParamType.INTEGER, "希望返回的相关知识条数，默认5", False, None), ] available_for_llm = global_config.lpmm_knowledge.enable diff --git a/src/webui/anti_crawler.py b/src/webui/anti_crawler.py new file mode 100644 index 00000000..28d87170 --- /dev/null +++ b/src/webui/anti_crawler.py @@ -0,0 +1,796 @@ +""" +WebUI 防爬虫模块 +提供爬虫检测和阻止功能，保护 WebUI 不被搜索引擎和恶意爬虫访问 +""" + +import os +import time +import ipaddress +import re +from collections import deque +from typing import Optional +from starlette.middleware.base import BaseHTTPMiddleware +from starlette.requests import Request +from starlette.responses import PlainTextResponse + +from src.common.logger import get_logger + +logger = get_logger("webui.anti_crawler") + +# 常见爬虫 User-Agent 列表（使用更精确的关键词，避免误报） +CRAWLER_USER_AGENTS = { + # 搜索引擎爬虫（精确匹配） + "googlebot", + "bingbot", + "baiduspider", + "yandexbot", + "slurp", # Yahoo + "duckduckbot", + "sogou", + "exabot", + "facebot", + "ia_archiver", # Internet Archive + # 通用爬虫（移除过于宽泛的关键词） + "crawler", + "spider", + "scraper", + "wget", # 保留wget，因为通常用于自动化脚本 + "scrapy", # 保留scrapy，因为这是爬虫框架 + # 安全扫描工具（这些是明确的扫描工具） + "masscan", + "nmap", + "nikto", + "sqlmap", + # 注意：移除了以下过于宽泛的关键词以避免误报： + # - "bot" (会误匹配GitHub-Robot等) + # - "curl" (正常工具) + # - "python-requests" (正常库) + # - "httpx" (正常库) + # - "aiohttp" (正常库) +} + +# 资产测绘工具 User-Agent 标识 +ASSET_SCANNER_USER_AGENTS = { + # 知名资产测绘平台 + "shodan", + "censys", + "zoomeye", + "fofa", + "quake", + "hunter", + "binaryedge", + "onyphe", + "securitytrails", + "virustotal", + "passivetotal", + # 安全扫描工具 + "acunetix", + "appscan", + "burpsuite", + "nessus", + "openvas", + "qualys", + "rapid7", + "tenable", + "veracode", + "zap", + "awvs", # Acunetix Web Vulnerability Scanner + "netsparker", + "skipfish", + "w3af", + "arachni", + # 其他扫描工具 + "masscan", + "zmap", + "nmap", + "whatweb", + "wpscan", + "joomscan", + "dnsenum", + "subfinder", + "amass", + "sublist3r", + "theharvester", +} + +# 资产测绘工具常用的HTTP头标识 +ASSET_SCANNER_HEADERS = { + # 常见的扫描工具自定义头 + "x-scan": {"shodan", "censys", "zoomeye", "fofa"}, + "x-scanner": {"nmap", "masscan", "zmap"}, + "x-probe": {"masscan", "zmap"}, + # 其他可疑头（移除反向代理标准头） + "x-originating-ip": set(), + "x-remote-ip": set(), + "x-remote-addr": set(), + # 注意：移除了以下反向代理标准头以避免误报： + # - "x-forwarded-proto" (反向代理标准头) + # - "x-real-ip" (反向代理标准头，已在_get_client_ip中使用) +} + +# 仅检查特定HTTP头中的可疑模式（收紧匹配范围） +# 只检查这些特定头，不检查所有头 +SCANNER_SPECIFIC_HEADERS = { + "x-scan", + "x-scanner", + "x-probe", + "x-originating-ip", + "x-remote-ip", + "x-remote-addr", +} + +# 防爬虫模式配置 +# false: 禁用 +# strict: 严格模式（更严格的检测，更低的频率限制） +# loose: 宽松模式（较宽松的检测，较高的频率限制） +# basic: 基础模式（只记录恶意访问，不阻止，不限制请求数，不跟踪IP） + +# IP白名单配置（从配置文件读取，逗号分隔） +# 支持格式： +# - 精确IP：127.0.0.1, 192.168.1.100 +# - CIDR格式：192.168.1.0/24, 172.17.0.0/16 (适用于Docker网络) +# - 通配符：192.168.*.*, 10.*.*.*, *.*.*.* (匹配所有) +# - IPv6：::1, 2001:db8::/32 +def _parse_allowed_ips(ip_string: str) -> list: + """ + 解析IP白名单字符串，支持精确IP、CIDR格式和通配符 + + Args: + ip_string: 逗号分隔的IP字符串 + + Returns: + IP白名单列表，每个元素可能是： + - ipaddress.IPv4Network/IPv6Network对象（CIDR格式） + - ipaddress.IPv4Address/IPv6Address对象（精确IP） + - str（通配符模式，已转换为正则表达式） + """ + allowed = [] + if not ip_string: + return allowed + + for ip_entry in ip_string.split(","): + ip_entry = ip_entry.strip() # 去除空格 + if not ip_entry: + continue + + # 跳过注释行（以#开头） + if ip_entry.startswith("#"): + continue + + # 检查通配符格式（包含*） + if "*" in ip_entry: + # 处理通配符 + pattern = _convert_wildcard_to_regex(ip_entry) + if pattern: + allowed.append(pattern) + else: + logger.warning(f"无效的通配符IP格式，已忽略: {ip_entry}") + continue + + try: + # 尝试解析为CIDR格式（包含/） + if "/" in ip_entry: + allowed.append(ipaddress.ip_network(ip_entry, strict=False)) + else: + # 精确IP地址 + allowed.append(ipaddress.ip_address(ip_entry)) + except (ValueError, AttributeError) as e: + logger.warning(f"无效的IP白名单条目，已忽略: {ip_entry} ({e})") + + return allowed + + +def _convert_wildcard_to_regex(wildcard_pattern: str) -> Optional[str]: + """ + 将通配符IP模式转换为正则表达式 + + 支持的格式： + - 192.168.*.* 或 192.168.* + - 10.*.*.* 或 10.* + - *.*.*.* 或 * + + Args: + wildcard_pattern: 通配符模式字符串 + + Returns: + 正则表达式字符串，如果格式无效则返回None + """ + # 去除空格 + pattern = wildcard_pattern.strip() + + # 处理单个*（匹配所有） + if pattern == "*": + return r".*" + + # 处理IPv4通配符格式 + # 支持：192.168.*.*, 192.168.*, 10.*.*.*, 10.* 等 + parts = pattern.split(".") + + if len(parts) > 4: + return None # IPv4最多4段 + + # 构建正则表达式 + regex_parts = [] + for part in parts: + part = part.strip() + if part == "*": + regex_parts.append(r"\d+") # 匹配任意数字 + elif part.isdigit(): + # 验证数字范围（0-255） + num = int(part) + if 0 <= num <= 255: + regex_parts.append(re.escape(part)) + else: + return None # 无效的数字 + else: + return None # 无效的格式 + + # 如果部分少于4段，补充.* + while len(regex_parts) < 4: + regex_parts.append(r"\d+") + + # 组合成正则表达式 + regex = r"^" + r"\.".join(regex_parts) + r"$" + return regex + + +# 从配置读取防爬虫设置（延迟导入避免循环依赖） +def _get_anti_crawler_config(): + """获取防爬虫配置""" + from src.config.config import global_config + return { + 'mode': global_config.webui.anti_crawler_mode, + 'allowed_ips': _parse_allowed_ips(global_config.webui.allowed_ips), + 'trusted_proxies': _parse_allowed_ips(global_config.webui.trusted_proxies), + 'trust_xff': global_config.webui.trust_xff + } + +# 初始化配置（将在模块加载时执行） +_config = _get_anti_crawler_config() +ANTI_CRAWLER_MODE = _config['mode'] +ALLOWED_IPS = _config['allowed_ips'] +TRUSTED_PROXIES = _config['trusted_proxies'] +TRUST_XFF = _config['trust_xff'] + + +def _get_mode_config(mode: str) -> dict: + """ + 根据模式获取配置参数 + + Args: + mode: 防爬虫模式 (false/strict/loose/basic) + + Returns: + 配置字典，包含所有相关参数 + """ + mode = mode.lower() + + if mode == "false": + return { + "enabled": False, + "rate_limit_window": 60, + "rate_limit_max_requests": 1000, # 禁用时设置很高的值 + "max_tracked_ips": 0, + "check_user_agent": False, + "check_asset_scanner": False, + "check_rate_limit": False, + "block_on_detect": False, # 不阻止 + } + elif mode == "strict": + return { + "enabled": True, + "rate_limit_window": 60, + "rate_limit_max_requests": 15, # 严格模式：更低的请求数 + "max_tracked_ips": 20000, + "check_user_agent": True, + "check_asset_scanner": True, + "check_rate_limit": True, + "block_on_detect": True, # 阻止恶意访问 + } + elif mode == "loose": + return { + "enabled": True, + "rate_limit_window": 60, + "rate_limit_max_requests": 60, # 宽松模式：更高的请求数 + "max_tracked_ips": 5000, + "check_user_agent": True, + "check_asset_scanner": True, + "check_rate_limit": True, + "block_on_detect": True, # 阻止恶意访问 + } + else: # basic (默认模式) + return { + "enabled": True, + "rate_limit_window": 60, + "rate_limit_max_requests": 1000, # 不限制请求数 + "max_tracked_ips": 0, # 不跟踪IP + "check_user_agent": True, # 检测但不阻止 + "check_asset_scanner": True, # 检测但不阻止 + "check_rate_limit": False, # 不限制请求频率 + "block_on_detect": False, # 只记录，不阻止 + } + + +class AntiCrawlerMiddleware(BaseHTTPMiddleware): + """防爬虫中间件""" + + def __init__(self, app, mode: str = "standard"): + """ + 初始化防爬虫中间件 + + Args: + app: FastAPI 应用实例 + mode: 防爬虫模式 (false/strict/loose/standard) + """ + super().__init__(app) + self.mode = mode.lower() + # 根据模式获取配置 + config = _get_mode_config(self.mode) + self.enabled = config["enabled"] + self.rate_limit_window = config["rate_limit_window"] + self.rate_limit_max_requests = config["rate_limit_max_requests"] + self.max_tracked_ips = config["max_tracked_ips"] + self.check_user_agent = config["check_user_agent"] + self.check_asset_scanner = config["check_asset_scanner"] + self.check_rate_limit = config["check_rate_limit"] + self.block_on_detect = config["block_on_detect"] # 是否阻止检测到的恶意访问 + + # 用于存储每个IP的请求时间戳（使用deque提高性能） + self.request_times: dict[str, deque] = {} + # 上次清理时间 + self.last_cleanup = time.time() + # 将关键词列表转换为集合以提高查找性能 + self.crawler_keywords_set = set(CRAWLER_USER_AGENTS) + self.scanner_keywords_set = set(ASSET_SCANNER_USER_AGENTS) + + def _is_crawler_user_agent(self, user_agent: Optional[str]) -> bool: + """ + 检测是否为爬虫 User-Agent + + Args: + user_agent: User-Agent 字符串 + + Returns: + 如果是爬虫则返回 True + """ + if not user_agent: + # 没有 User-Agent 的请求记录日志但不直接阻止 + # 改为只记录，让频率限制来处理 + logger.debug("请求缺少User-Agent") + return False # 不再直接阻止无User-Agent的请求 + + user_agent_lower = user_agent.lower() + + # 使用集合查找提高性能（检查是否包含爬虫关键词） + for crawler_keyword in self.crawler_keywords_set: + if crawler_keyword in user_agent_lower: + return True + + return False + + def _is_asset_scanner_header(self, request: Request) -> bool: + """ + 检测是否为资产测绘工具的HTTP头（只检查特定头，收紧匹配） + + Args: + request: 请求对象 + + Returns: + 如果检测到资产测绘工具头则返回 True + """ + # 只检查特定的扫描工具头，不检查所有头 + for header_name, header_value in request.headers.items(): + header_name_lower = header_name.lower() + header_value_lower = header_value.lower() if header_value else "" + + # 检查已知的扫描工具头 + if header_name_lower in ASSET_SCANNER_HEADERS: + # 如果该头有特定的工具集合，检查值是否匹配 + expected_tools = ASSET_SCANNER_HEADERS[header_name_lower] + if expected_tools: + for tool in expected_tools: + if tool in header_value_lower: + return True + else: + # 如果没有特定工具集合，只要存在该头就视为可疑 + if header_value_lower: + return True + + # 只检查特定头中的可疑模式（收紧匹配） + if header_name_lower in SCANNER_SPECIFIC_HEADERS: + # 检查头值中是否包含已知扫描工具名称 + for tool in self.scanner_keywords_set: + if tool in header_value_lower: + return True + + return False + + def _detect_asset_scanner(self, request: Request) -> tuple[bool, Optional[str]]: + """ + 检测资产测绘工具 + + Args: + request: 请求对象 + + Returns: + (是否检测到, 检测到的工具名称) + """ + user_agent = request.headers.get("User-Agent") + + # 检查 User-Agent（使用集合查找提高性能） + if user_agent: + user_agent_lower = user_agent.lower() + for scanner_keyword in self.scanner_keywords_set: + if scanner_keyword in user_agent_lower: + return True, scanner_keyword + + # 检查HTTP头 + if self._is_asset_scanner_header(request): + # 尝试从User-Agent或头中提取工具名称 + detected_tool = None + if user_agent: + user_agent_lower = user_agent.lower() + for tool in self.scanner_keywords_set: + if tool in user_agent_lower: + detected_tool = tool + break + + # 检查HTTP头中的工具标识（只检查特定头） + if not detected_tool: + for header_name, header_value in request.headers.items(): + header_name_lower = header_name.lower() + if header_name_lower in SCANNER_SPECIFIC_HEADERS: + header_value_lower = (header_value or "").lower() + for tool in self.scanner_keywords_set: + if tool in header_value_lower: + detected_tool = tool + break + if detected_tool: + break + + return True, detected_tool or "unknown_scanner" + + return False, None + + def _check_rate_limit(self, client_ip: str) -> bool: + """ + 检查请求频率限制 + + Args: + client_ip: 客户端IP地址 + + Returns: + 如果超过限制则返回 True（需要阻止） + """ + # 检查IP白名单 + if self._is_ip_allowed(client_ip): + return False + + current_time = time.time() + + # 定期清理过期的请求记录（每5分钟清理一次） + if current_time - self.last_cleanup > 300: + self._cleanup_old_requests(current_time) + self.last_cleanup = current_time + + # 限制跟踪的IP数量，防止内存泄漏 + if self.max_tracked_ips > 0 and len(self.request_times) > self.max_tracked_ips: + # 清理最旧的记录（删除最久未访问的IP） + self._cleanup_oldest_ips() + + # 获取或创建该IP的请求时间deque（不使用maxlen，避免限流变松） + if client_ip not in self.request_times: + self.request_times[client_ip] = deque() + + request_times = self.request_times[client_ip] + + # 移除时间窗口外的请求记录（从左侧弹出过期记录） + while request_times and current_time - request_times[0] >= self.rate_limit_window: + request_times.popleft() + + # 检查是否超过限制 + if len(request_times) >= self.rate_limit_max_requests: + return True + + # 记录当前请求时间 + request_times.append(current_time) + return False + + def _cleanup_old_requests(self, current_time: float): + """清理过期的请求记录（只清理当前需要检查的IP，不全量遍历）""" + # 这个方法现在主要用于定期清理，实际清理在_check_rate_limit中按需进行 + # 清理最久未访问的IP记录 + if len(self.request_times) > self.max_tracked_ips * 0.8: + self._cleanup_oldest_ips() + + def _cleanup_oldest_ips(self): + """清理最久未访问的IP记录（全量遍历找真正的oldest）""" + if not self.request_times: + return + + # 先收集空deque的IP（优先删除） + empty_ips = [] + # 找到最久未访问的IP（最旧时间戳） + oldest_ip = None + oldest_time = float("inf") + + # 全量遍历找真正的oldest（超限时性能可接受） + for ip, times in self.request_times.items(): + if not times: + # 空deque，记录待删除 + empty_ips.append(ip) + else: + # 找到最旧的时间戳 + if times[0] < oldest_time: + oldest_time = times[0] + oldest_ip = ip + + # 先删除空deque的IP + for ip in empty_ips: + del self.request_times[ip] + + # 如果没有空deque可删除，且仍需要清理，删除最旧的一个IP + if not empty_ips and oldest_ip: + del self.request_times[oldest_ip] + + def _is_trusted_proxy(self, ip: str) -> bool: + """ + 检查IP是否在信任的代理列表中 + + Args: + ip: IP地址字符串 + + Returns: + 如果是信任的代理则返回 True + """ + if not TRUSTED_PROXIES or ip == "unknown": + return False + + # 检查代理列表中的每个条目 + for trusted_entry in TRUSTED_PROXIES: + # 通配符模式（字符串，正则表达式） + if isinstance(trusted_entry, str): + try: + if re.match(trusted_entry, ip): + return True + except re.error: + continue + # CIDR格式（网络对象） + elif isinstance(trusted_entry, (ipaddress.IPv4Network, ipaddress.IPv6Network)): + try: + client_ip_obj = ipaddress.ip_address(ip) + if client_ip_obj in trusted_entry: + return True + except (ValueError, AttributeError): + continue + # 精确IP（地址对象） + elif isinstance(trusted_entry, (ipaddress.IPv4Address, ipaddress.IPv6Address)): + try: + client_ip_obj = ipaddress.ip_address(ip) + if client_ip_obj == trusted_entry: + return True + except (ValueError, AttributeError): + continue + + return False + + def _get_client_ip(self, request: Request) -> str: + """ + 获取客户端真实IP地址（带基本验证和代理信任检查） + + Args: + request: 请求对象 + + Returns: + 客户端IP地址 + """ + # 获取直接连接的客户端IP（用于验证代理） + direct_client_ip = None + if request.client: + direct_client_ip = request.client.host + + # 检查是否信任X-Forwarded-For头 + # TRUST_XFF 只表示"启用代理解析能力"，但仍要求直连 IP 在 TRUSTED_PROXIES 中 + use_xff = False + if TRUST_XFF and TRUSTED_PROXIES and direct_client_ip: + # 只有在启用 TRUST_XFF 且直连 IP 在信任列表中时，才信任 XFF + use_xff = self._is_trusted_proxy(direct_client_ip) + + # 如果信任代理，优先从 X-Forwarded-For 获取 + if use_xff: + forwarded_for = request.headers.get("X-Forwarded-For") + if forwarded_for: + # X-Forwarded-For 可能包含多个IP，取第一个 + ip = forwarded_for.split(",")[0].strip() + # 基本验证IP格式 + if self._validate_ip(ip): + return ip + + # 从 X-Real-IP 获取（如果信任代理） + if use_xff: + real_ip = request.headers.get("X-Real-IP") + if real_ip: + ip = real_ip.strip() + if self._validate_ip(ip): + return ip + + # 使用直接连接的客户端IP + if direct_client_ip and self._validate_ip(direct_client_ip): + return direct_client_ip + + return "unknown" + + def _validate_ip(self, ip: str) -> bool: + """ + 验证IP地址格式 + + Args: + ip: IP地址字符串 + + Returns: + 如果格式有效则返回 True + """ + try: + ipaddress.ip_address(ip) + return True + except (ValueError, AttributeError): + return False + + def _is_ip_allowed(self, ip: str) -> bool: + """ + 检查IP是否在白名单中（支持精确IP、CIDR格式和通配符） + + Args: + ip: 客户端IP地址 + + Returns: + 如果IP在白名单中则返回 True + """ + if not ALLOWED_IPS or ip == "unknown": + return False + + # 检查白名单中的每个条目 + for allowed_entry in ALLOWED_IPS: + # 通配符模式（字符串，正则表达式） + if isinstance(allowed_entry, str): + try: + if re.match(allowed_entry, ip): + return True + except re.error: + # 正则表达式错误，跳过 + continue + # CIDR格式（网络对象） + elif isinstance(allowed_entry, (ipaddress.IPv4Network, ipaddress.IPv6Network)): + try: + client_ip_obj = ipaddress.ip_address(ip) + if client_ip_obj in allowed_entry: + return True + except (ValueError, AttributeError): + # IP格式无效，跳过 + continue + # 精确IP（地址对象） + elif isinstance(allowed_entry, (ipaddress.IPv4Address, ipaddress.IPv6Address)): + try: + client_ip_obj = ipaddress.ip_address(ip) + if client_ip_obj == allowed_entry: + return True + except (ValueError, AttributeError): + # IP格式无效，跳过 + continue + + return False + + async def dispatch(self, request: Request, call_next): + """ + 处理请求 + + Args: + request: 请求对象 + call_next: 下一个中间件或路由处理函数 + + Returns: + 响应对象 + """ + # 如果未启用，直接通过 + if not self.enabled: + return await call_next(request) + + # 允许访问 robots.txt（由专门的路由处理） + if request.url.path == "/robots.txt": + return await call_next(request) + + # 允许访问静态资源（CSS、JS、图片等） + # 注意：.json 已移除，避免 API 路径绕过防护 + # 静态资源只在特定前缀下放行（/static/、/assets/、/dist/） + static_extensions = { + ".css", + ".js", + ".png", + ".jpg", + ".jpeg", + ".gif", + ".svg", + ".ico", + ".woff", + ".woff2", + ".ttf", + ".eot", + } + static_prefixes = {"/static/", "/assets/", "/dist/"} + + # 检查是否是静态资源路径（特定前缀下的静态文件） + path = request.url.path + is_static_path = any(path.startswith(prefix) for prefix in static_prefixes) and any( + path.endswith(ext) for ext in static_extensions + ) + + # 也允许根路径下的静态文件（如 /favicon.ico） + is_root_static = path.count("/") == 1 and any(path.endswith(ext) for ext in static_extensions) + + if is_static_path or is_root_static: + return await call_next(request) + + # 获取客户端IP（只获取一次，避免重复调用） + client_ip = self._get_client_ip(request) + + # 检查IP白名单（优先检查，白名单IP直接通过） + if self._is_ip_allowed(client_ip): + return await call_next(request) + + # 获取 User-Agent + user_agent = request.headers.get("User-Agent") + + # 检测资产测绘工具（优先检测，因为更危险） + if self.check_asset_scanner: + is_scanner, scanner_name = self._detect_asset_scanner(request) + if is_scanner: + logger.warning( + f"🚫 检测到资产测绘工具请求 - IP: {client_ip}, 工具: {scanner_name}, " + f"User-Agent: {user_agent}, Path: {request.url.path}" + ) + # 根据配置决定是否阻止 + if self.block_on_detect: + return PlainTextResponse( + "Access Denied: Asset scanning tools are not allowed", + status_code=403, + ) + + # 检测爬虫 User-Agent + if self.check_user_agent and self._is_crawler_user_agent(user_agent): + logger.warning(f"🚫 检测到爬虫请求 - IP: {client_ip}, User-Agent: {user_agent}, Path: {request.url.path}") + # 根据配置决定是否阻止 + if self.block_on_detect: + return PlainTextResponse( + "Access Denied: Crawlers are not allowed", + status_code=403, + ) + + # 检查请求频率限制 + if self.check_rate_limit and self._check_rate_limit(client_ip): + logger.warning(f"🚫 请求频率过高 - IP: {client_ip}, User-Agent: {user_agent}, Path: {request.url.path}") + return PlainTextResponse( + "Too Many Requests: Rate limit exceeded", + status_code=429, + ) + + # 正常请求，继续处理 + return await call_next(request) + + +def create_robots_txt_response() -> PlainTextResponse: + """ + 创建 robots.txt 响应 + + Returns: + robots.txt 响应对象 + """ + robots_content = """User-agent: * +Disallow: / + +# 禁止所有爬虫访问 +""" + return PlainTextResponse( + content=robots_content, + media_type="text/plain", + headers={"Cache-Control": "public, max-age=86400"}, # 缓存24小时 + ) diff --git a/src/webui/auth.py b/src/webui/auth.py new file mode 100644 index 00000000..db0fc675 --- /dev/null +++ b/src/webui/auth.py @@ -0,0 +1,183 @@ +""" +WebUI 认证模块 +提供统一的认证依赖，支持 Cookie 和 Header 两种方式 +""" + +from typing import Optional +from fastapi import HTTPException, Cookie, Header, Response, Request +from src.common.logger import get_logger +from src.config.config import global_config +from .token_manager import get_token_manager + +logger = get_logger("webui.auth") + +# Cookie 配置 +COOKIE_NAME = "maibot_session" +COOKIE_MAX_AGE = 7 * 24 * 60 * 60 # 7天 + + +def _is_secure_environment() -> bool: + """ + 检测是否应该启用安全 Cookie（HTTPS） + + Returns: + bool: 如果应该使用 secure cookie 则返回 True + """ + # 从配置读取 + if global_config.webui.secure_cookie: + logger.info("配置中启用了 secure_cookie") + return True + + # 检查是否是生产环境 + if global_config.webui.mode == "production": + logger.info("WebUI运行在生产模式，启用 secure cookie") + return True + + # 默认：开发环境不启用（因为通常是 HTTP） + logger.debug("WebUI运行在开发模式，禁用 secure cookie") + return False + + +def get_current_token( + request: Request, + maibot_session: Optional[str] = Cookie(None), + authorization: Optional[str] = Header(None), +) -> str: + """ + 获取当前请求的 token，优先从 Cookie 获取，其次从 Header 获取 + + Args: + request: FastAPI Request 对象 + maibot_session: Cookie 中的 token + authorization: Authorization Header (Bearer token) + + Returns: + 验证通过的 token + + Raises: + HTTPException: 认证失败时抛出 401 错误 + """ + token = None + + # 优先从 Cookie 获取 + if maibot_session: + token = maibot_session + # 其次从 Header 获取（兼容旧版本） + elif authorization and authorization.startswith("Bearer "): + token = authorization.replace("Bearer ", "") + + if not token: + raise HTTPException(status_code=401, detail="未提供有效的认证信息") + + # 验证 token + token_manager = get_token_manager() + if not token_manager.verify_token(token): + raise HTTPException(status_code=401, detail="Token 无效或已过期") + + return token + + +def set_auth_cookie(response: Response, token: str, request: Optional[Request] = None) -> None: + """ + 设置认证 Cookie + + Args: + response: FastAPI Response 对象 + token: 要设置的 token + request: FastAPI Request 对象（可选，用于检测协议） + """ + # 根据环境和实际请求协议决定安全设置 + is_secure = _is_secure_environment() + + # 如果提供了 request，检测实际使用的协议 + if request: + # 检查 X-Forwarded-Proto header（代理/负载均衡器） + forwarded_proto = request.headers.get("x-forwarded-proto", "").lower() + if forwarded_proto: + is_https = forwarded_proto == "https" + logger.debug(f"检测到 X-Forwarded-Proto: {forwarded_proto}, is_https={is_https}") + else: + # 检查 request.url.scheme + is_https = request.url.scheme == "https" + logger.debug(f"检测到 scheme: {request.url.scheme}, is_https={is_https}") + + # 如果是 HTTP 连接，强制禁用 secure 标志 + if not is_https and is_secure: + logger.warning("=" * 80) + logger.warning("检测到 HTTP 连接但环境配置要求 HTTPS (secure cookie)") + logger.warning("已自动禁用 secure 标志以允许登录，但建议修改配置：") + logger.warning("1. 在配置文件中设置: webui.secure_cookie = false") + logger.warning("2. 如果使用反向代理，请确保正确配置 X-Forwarded-Proto 头") + logger.warning("=" * 80) + is_secure = False + + # 设置 Cookie + response.set_cookie( + key=COOKIE_NAME, + value=token, + max_age=COOKIE_MAX_AGE, + httponly=True, # 防止 JS 读取，阻止 XSS 窃取 + samesite="lax", # 使用 lax 以兼容更多场景（开发和生产） + secure=is_secure, # 根据实际协议决定 + path="/", # 确保 Cookie 在所有路径下可用 + ) + + logger.info(f"已设置认证 Cookie: {token[:8]}... (secure={is_secure}, samesite=lax, httponly=True, path=/, max_age={COOKIE_MAX_AGE})") + logger.debug(f"完整 token 前缀: {token[:20]}...") + + +def clear_auth_cookie(response: Response) -> None: + """ + 清除认证 Cookie + + Args: + response: FastAPI Response 对象 + """ + # 保持与 set_auth_cookie 相同的安全设置 + is_secure = _is_secure_environment() + + response.delete_cookie( + key=COOKIE_NAME, + httponly=True, + samesite="strict" if is_secure else "lax", + secure=is_secure, + path="/", + ) + logger.debug("已清除认证 Cookie") + + +def verify_auth_token_from_cookie_or_header( + maibot_session: Optional[str] = None, + authorization: Optional[str] = None, +) -> bool: + """ + 验证认证 Token，支持从 Cookie 或 Header 获取 + + Args: + maibot_session: Cookie 中的 token + authorization: Authorization header (Bearer token) + + Returns: + 验证成功返回 True + + Raises: + HTTPException: 认证失败时抛出 401 错误 + """ + token = None + + # 优先从 Cookie 获取 + if maibot_session: + token = maibot_session + # 其次从 Header 获取（兼容旧版本） + elif authorization and authorization.startswith("Bearer "): + token = authorization.replace("Bearer ", "") + + if not token: + raise HTTPException(status_code=401, detail="未提供有效的认证信息") + + # 验证 token + token_manager = get_token_manager() + if not token_manager.verify_token(token): + raise HTTPException(status_code=401, detail="Token 无效或已过期") + + return True diff --git a/src/webui/chat_routes.py b/src/webui/chat_routes.py new file mode 100644 index 00000000..6535b9e9 --- /dev/null +++ b/src/webui/chat_routes.py @@ -0,0 +1,782 @@ +"""本地聊天室路由 - WebUI 与麦麦直接对话 + +支持两种模式： +1. WebUI 模式：使用 WebUI 平台独立身份聊天 +2. 虚拟身份模式：使用真实平台用户的身份，在虚拟群聊中与麦麦对话 +""" + +import time +import uuid +from typing import Dict, Any, Optional, List +from fastapi import APIRouter, WebSocket, WebSocketDisconnect, Query, Depends, Cookie, Header +from pydantic import BaseModel + +from src.common.logger import get_logger +from src.common.database.database_model import Messages, PersonInfo +from src.config.config import global_config +from src.chat.message_receive.bot import chat_bot +from src.webui.auth import verify_auth_token_from_cookie_or_header +from src.webui.token_manager import get_token_manager +from src.webui.ws_auth import verify_ws_token + +logger = get_logger("webui.chat") + +router = APIRouter(prefix="/api/chat", tags=["LocalChat"]) + + +def require_auth( + maibot_session: Optional[str] = Cookie(None), + authorization: Optional[str] = Header(None), +) -> bool: + """认证依赖：验证用户是否已登录""" + return verify_auth_token_from_cookie_or_header(maibot_session, authorization) + + +# WebUI 聊天的虚拟群组 ID +WEBUI_CHAT_GROUP_ID = "webui_local_chat" +WEBUI_CHAT_PLATFORM = "webui" + +# 虚拟身份模式的群 ID 前缀 +VIRTUAL_GROUP_ID_PREFIX = "webui_virtual_group_" + +# 固定的 WebUI 用户 ID 前缀 +WEBUI_USER_ID_PREFIX = "webui_user_" + + +class VirtualIdentityConfig(BaseModel): + """虚拟身份配置""" + + enabled: bool = False # 是否启用虚拟身份模式 + platform: Optional[str] = None # 目标平台（如 qq, discord 等） + person_id: Optional[str] = None # PersonInfo 的 person_id + user_id: Optional[str] = None # 原始平台用户 ID + user_nickname: Optional[str] = None # 用户昵称 + group_id: Optional[str] = None # 虚拟群 ID（自动生成或用户指定） + group_name: Optional[str] = None # 虚拟群名（用户自定义） + + +class ChatHistoryMessage(BaseModel): + """聊天历史消息""" + + id: str + type: str # 'user' | 'bot' | 'system' + content: str + timestamp: float + sender_name: str + sender_id: Optional[str] = None + is_bot: bool = False + + +class ChatHistoryManager: + """聊天历史管理器 - 使用 SQLite 数据库存储""" + + def __init__(self, max_messages: int = 200): + self.max_messages = max_messages + + def _message_to_dict(self, msg: Messages, group_id: Optional[str] = None) -> Dict[str, Any]: + """将数据库消息转换为前端格式 + + Args: + msg: 数据库消息对象 + group_id: 群 ID，用于判断是否是虚拟群 + """ + # 判断是否是机器人消息 + user_id = msg.user_id or "" + + # 对于虚拟群，通过比较机器人 QQ 账号来判断 + # 对于普通 WebUI 群，检查 user_id 是否以 webui_ 开头 + if group_id and group_id.startswith(VIRTUAL_GROUP_ID_PREFIX): + # 虚拟群：user_id 等于机器人 QQ 账号的是机器人消息 + bot_qq = str(global_config.bot.qq_account) + is_bot = user_id == bot_qq + else: + # 普通 WebUI 群：不以 webui_ 开头的是机器人消息 + is_bot = not user_id.startswith("webui_") and not user_id.startswith(WEBUI_USER_ID_PREFIX) + + return { + "id": msg.message_id, + "type": "bot" if is_bot else "user", + "content": msg.processed_plain_text or msg.display_message or "", + "timestamp": msg.time, + "sender_name": msg.user_nickname or (global_config.bot.nickname if is_bot else "未知用户"), + "sender_id": "bot" if is_bot else user_id, + "is_bot": is_bot, + } + + def get_history(self, limit: int = 50, group_id: Optional[str] = None) -> List[Dict[str, Any]]: + """从数据库获取最近的历史记录 + + Args: + limit: 获取的消息数量 + group_id: 群 ID，默认为 WEBUI_CHAT_GROUP_ID + """ + target_group_id = group_id if group_id else WEBUI_CHAT_GROUP_ID + try: + # 查询指定群的消息，按时间排序 + messages = ( + Messages.select() + .where(Messages.chat_info_group_id == target_group_id) + .order_by(Messages.time.desc()) + .limit(limit) + ) + + # 转换为列表并反转（使最旧的消息在前） + # 传递 group_id 以便正确判断虚拟群中的机器人消息 + result = [self._message_to_dict(msg, target_group_id) for msg in messages] + result.reverse() + + logger.debug(f"从数据库加载了 {len(result)} 条聊天记录 (group_id={target_group_id})") + return result + except Exception as e: + logger.error(f"从数据库加载聊天记录失败: {e}") + return [] + + def clear_history(self, group_id: Optional[str] = None) -> int: + """清空聊天历史记录 + + Args: + group_id: 群 ID，默认清空 WebUI 默认聊天室 + """ + target_group_id = group_id if group_id else WEBUI_CHAT_GROUP_ID + try: + deleted = Messages.delete().where(Messages.chat_info_group_id == target_group_id).execute() + logger.info(f"已清空 {deleted} 条聊天记录 (group_id={target_group_id})") + return deleted + except Exception as e: + logger.error(f"清空聊天记录失败: {e}") + return 0 + + +# 全局聊天历史管理器 +chat_history = ChatHistoryManager() + + +# 存储 WebSocket 连接 +class ChatConnectionManager: + """聊天连接管理器""" + + def __init__(self): + self.active_connections: Dict[str, WebSocket] = {} + self.user_sessions: Dict[str, str] = {} # user_id -> session_id 映射 + + async def connect(self, websocket: WebSocket, session_id: str, user_id: str): + await websocket.accept() + self.active_connections[session_id] = websocket + self.user_sessions[user_id] = session_id + logger.info(f"WebUI 聊天会话已连接: session={session_id}, user={user_id}") + + def disconnect(self, session_id: str, user_id: str): + if session_id in self.active_connections: + del self.active_connections[session_id] + if user_id in self.user_sessions and self.user_sessions[user_id] == session_id: + del self.user_sessions[user_id] + logger.info(f"WebUI 聊天会话已断开: session={session_id}") + + async def send_message(self, session_id: str, message: dict): + if session_id in self.active_connections: + try: + await self.active_connections[session_id].send_json(message) + except Exception as e: + logger.error(f"发送消息失败: {e}") + + async def broadcast(self, message: dict): + """广播消息给所有连接""" + for session_id in list(self.active_connections.keys()): + await self.send_message(session_id, message) + + +chat_manager = ChatConnectionManager() + + +def create_message_data( + content: str, + user_id: str, + user_name: str, + message_id: Optional[str] = None, + is_at_bot: bool = True, + virtual_config: Optional[VirtualIdentityConfig] = None, +) -> Dict[str, Any]: + """创建符合麦麦消息格式的消息数据 + + Args: + content: 消息内容 + user_id: 用户 ID + user_name: 用户昵称 + message_id: 消息 ID（可选，自动生成） + is_at_bot: 是否 @ 机器人 + virtual_config: 虚拟身份配置（可选，启用后使用真实平台身份） + """ + if message_id is None: + message_id = str(uuid.uuid4()) + + # 确定使用的平台、群信息和用户信息 + if virtual_config and virtual_config.enabled: + # 虚拟身份模式：使用真实平台身份 + platform = virtual_config.platform or WEBUI_CHAT_PLATFORM + group_id = virtual_config.group_id or f"{VIRTUAL_GROUP_ID_PREFIX}{uuid.uuid4().hex[:8]}" + group_name = virtual_config.group_name or "WebUI虚拟群聊" + actual_user_id = virtual_config.user_id or user_id + actual_user_name = virtual_config.user_nickname or user_name + else: + # 标准 WebUI 模式 + platform = WEBUI_CHAT_PLATFORM + group_id = WEBUI_CHAT_GROUP_ID + group_name = "WebUI本地聊天室" + actual_user_id = user_id + actual_user_name = user_name + + return { + "message_info": { + "platform": platform, + "message_id": message_id, + "time": time.time(), + "group_info": { + "group_id": group_id, + "group_name": group_name, + "platform": platform, + }, + "user_info": { + "user_id": actual_user_id, + "user_nickname": actual_user_name, + "user_cardname": actual_user_name, + "platform": platform, + }, + "additional_config": { + "at_bot": is_at_bot, + }, + }, + "message_segment": { + "type": "seglist", + "data": [ + { + "type": "text", + "data": content, + }, + { + "type": "mention_bot", + "data": "1.0", + }, + ], + }, + "raw_message": content, + "processed_plain_text": content, + } + + +@router.get("/history") +async def get_chat_history( + limit: int = Query(default=50, ge=1, le=200), + user_id: Optional[str] = Query(default=None), # 保留参数兼容性，但不用于过滤 + group_id: Optional[str] = Query(default=None), # 可选：指定群 ID 获取历史 + _auth: bool = Depends(require_auth), +): + """获取聊天历史记录 + + 所有 WebUI 用户共享同一个聊天室，因此返回所有历史记录 + 如果指定了 group_id，则获取该虚拟群的历史记录 + """ + target_group_id = group_id if group_id else WEBUI_CHAT_GROUP_ID + history = chat_history.get_history(limit, target_group_id) + return { + "success": True, + "messages": history, + "total": len(history), + } + + +@router.get("/platforms") +async def get_available_platforms(_auth: bool = Depends(require_auth)): + """获取可用平台列表 + + 从 PersonInfo 表中获取所有已知的平台 + """ + try: + from peewee import fn + + # 查询所有不同的平台 + platforms = ( + PersonInfo.select(PersonInfo.platform, fn.COUNT(PersonInfo.id).alias("count")) + .group_by(PersonInfo.platform) + .order_by(fn.COUNT(PersonInfo.id).desc()) + ) + + result = [] + for p in platforms: + if p.platform: # 排除空平台 + result.append({"platform": p.platform, "count": p.count}) + + return {"success": True, "platforms": result} + except Exception as e: + logger.error(f"获取平台列表失败: {e}") + return {"success": False, "error": str(e), "platforms": []} + + +@router.get("/persons") +async def get_persons_by_platform( + platform: str = Query(..., description="平台名称"), + search: Optional[str] = Query(default=None, description="搜索关键词"), + limit: int = Query(default=50, ge=1, le=200), + _auth: bool = Depends(require_auth), +): + """获取指定平台的用户列表 + + Args: + platform: 平台名称（如 qq, discord 等） + search: 搜索关键词（匹配昵称、用户名、user_id） + limit: 返回数量限制 + """ + try: + # 构建查询 + query = PersonInfo.select().where(PersonInfo.platform == platform) + + # 搜索过滤 + if search: + query = query.where( + (PersonInfo.person_name.contains(search)) + | (PersonInfo.nickname.contains(search)) + | (PersonInfo.user_id.contains(search)) + ) + + # 按最后交互时间排序，优先显示活跃用户 + from peewee import Case + + query = query.order_by(Case(None, [(PersonInfo.last_know.is_null(), 1)], 0), PersonInfo.last_know.desc()) + query = query.limit(limit) + + result = [] + for person in query: + result.append( + { + "person_id": person.person_id, + "user_id": person.user_id, + "person_name": person.person_name, + "nickname": person.nickname, + "is_known": person.is_known, + "platform": person.platform, + "display_name": person.person_name or person.nickname or person.user_id, + } + ) + + return {"success": True, "persons": result, "total": len(result)} + except Exception as e: + logger.error(f"获取用户列表失败: {e}") + return {"success": False, "error": str(e), "persons": []} + + +@router.delete("/history") +async def clear_chat_history(group_id: Optional[str] = Query(default=None), _auth: bool = Depends(require_auth)): + """清空聊天历史记录 + + Args: + group_id: 可选，指定要清空的群 ID，默认清空 WebUI 默认聊天室 + """ + deleted = chat_history.clear_history(group_id) + return { + "success": True, + "message": f"已清空 {deleted} 条聊天记录", + } + + +@router.websocket("/ws") +async def websocket_chat( + websocket: WebSocket, + user_id: Optional[str] = Query(default=None), + user_name: Optional[str] = Query(default="WebUI用户"), + platform: Optional[str] = Query(default=None), + person_id: Optional[str] = Query(default=None), + group_name: Optional[str] = Query(default=None), + group_id: Optional[str] = Query(default=None), # 前端传递的稳定 group_id + token: Optional[str] = Query(default=None), # 认证 token +): + """WebSocket 聊天端点 + + Args: + user_id: 用户唯一标识（由前端生成并持久化） + user_name: 用户显示昵称（可修改） + platform: 虚拟身份模式的平台（可选） + person_id: 虚拟身份模式的用户 person_id（可选） + group_name: 虚拟身份模式的群名（可选） + group_id: 虚拟身份模式的群 ID（可选，由前端生成并持久化） + token: 认证 token（可选，也可从 Cookie 获取） + + 虚拟身份模式可通过 URL 参数直接配置，或通过消息中的 set_virtual_identity 配置 + + 支持三种认证方式（按优先级）： + 1. query 参数 token（推荐，通过 /api/webui/ws-token 获取临时 token） + 2. Cookie 中的 maibot_session + 3. 直接使用 session token（兼容） + + 示例：ws://host/api/chat/ws?token=xxx + """ + is_authenticated = False + + # 方式 1: 尝试验证临时 WebSocket token（推荐方式） + if token and verify_ws_token(token): + is_authenticated = True + logger.debug("聊天 WebSocket 使用临时 token 认证成功") + + # 方式 2: 尝试从 Cookie 获取 session token + if not is_authenticated: + cookie_token = websocket.cookies.get("maibot_session") + if cookie_token: + token_manager = get_token_manager() + if token_manager.verify_token(cookie_token): + is_authenticated = True + logger.debug("聊天 WebSocket 使用 Cookie 认证成功") + + # 方式 3: 尝试直接验证 query 参数作为 session token（兼容旧方式） + if not is_authenticated and token: + token_manager = get_token_manager() + if token_manager.verify_token(token): + is_authenticated = True + logger.debug("聊天 WebSocket 使用 session token 认证成功") + + if not is_authenticated: + logger.warning("聊天 WebSocket 连接被拒绝：认证失败") + await websocket.close(code=4001, reason="认证失败，请重新登录") + return + + # 生成会话 ID（每次连接都是新的） + session_id = str(uuid.uuid4()) + + # 如果没有提供 user_id，生成一个新的 + if not user_id: + user_id = f"{WEBUI_USER_ID_PREFIX}{uuid.uuid4().hex[:16]}" + elif not user_id.startswith(WEBUI_USER_ID_PREFIX): + # 确保 user_id 有正确的前缀 + user_id = f"{WEBUI_USER_ID_PREFIX}{user_id}" + + # 当前会话的虚拟身份配置（可通过消息动态更新） + current_virtual_config: Optional[VirtualIdentityConfig] = None + + # 如果 URL 参数中提供了虚拟身份信息，自动配置 + if platform and person_id: + try: + person = PersonInfo.get_or_none(PersonInfo.person_id == person_id) + if person: + # 使用前端传递的 group_id，如果没有则生成一个稳定的 + virtual_group_id = group_id or f"{VIRTUAL_GROUP_ID_PREFIX}{platform}_{person.user_id}" + current_virtual_config = VirtualIdentityConfig( + enabled=True, + platform=person.platform, + person_id=person.person_id, + user_id=person.user_id, + user_nickname=person.person_name or person.nickname or person.user_id, + group_id=virtual_group_id, + group_name=group_name or "WebUI虚拟群聊", + ) + logger.info( + f"虚拟身份模式已通过 URL 参数激活: {current_virtual_config.user_nickname} @ {current_virtual_config.platform}, group_id={virtual_group_id}" + ) + except Exception as e: + logger.warning(f"通过 URL 参数配置虚拟身份失败: {e}") + + await chat_manager.connect(websocket, session_id, user_id) + + try: + # 构建会话信息 + session_info_data = { + "type": "session_info", + "session_id": session_id, + "user_id": user_id, + "user_name": user_name, + "bot_name": global_config.bot.nickname, + } + + # 如果有虚拟身份配置，添加到会话信息中 + if current_virtual_config and current_virtual_config.enabled: + session_info_data["virtual_mode"] = True + session_info_data["group_id"] = current_virtual_config.group_id + session_info_data["virtual_identity"] = { + "platform": current_virtual_config.platform, + "user_id": current_virtual_config.user_id, + "user_nickname": current_virtual_config.user_nickname, + "group_name": current_virtual_config.group_name, + } + + # 发送会话信息（包含用户 ID，前端需要保存） + await chat_manager.send_message(session_id, session_info_data) + + # 发送历史记录（根据模式选择不同的群） + if current_virtual_config and current_virtual_config.enabled: + history = chat_history.get_history(50, current_virtual_config.group_id) + else: + history = chat_history.get_history(50) + if history: + await chat_manager.send_message( + session_id, + { + "type": "history", + "messages": history, + }, + ) + + # 发送欢迎消息（不保存到历史） + if current_virtual_config and current_virtual_config.enabled: + welcome_msg = f"已以 {current_virtual_config.user_nickname} 的身份连接到「{current_virtual_config.group_name}」，开始与 {global_config.bot.nickname} 对话吧！" + else: + welcome_msg = f"已连接到本地聊天室，可以开始与 {global_config.bot.nickname} 对话了！" + + await chat_manager.send_message( + session_id, + { + "type": "system", + "content": welcome_msg, + "timestamp": time.time(), + }, + ) + + while True: + data = await websocket.receive_json() + + if data.get("type") == "message": + content = data.get("content", "").strip() + if not content: + continue + + # 用户可以更新昵称 + current_user_name = data.get("user_name", user_name) + + message_id = str(uuid.uuid4()) + timestamp = time.time() + + # 确定发送者信息（根据是否使用虚拟身份） + if current_virtual_config and current_virtual_config.enabled: + sender_name = current_virtual_config.user_nickname or current_user_name + sender_user_id = current_virtual_config.user_id or user_id + else: + sender_name = current_user_name + sender_user_id = user_id + + # 广播用户消息给所有连接（包括发送者） + # 注意：用户消息会在 chat_bot.message_process 中自动保存到数据库 + await chat_manager.broadcast( + { + "type": "user_message", + "content": content, + "message_id": message_id, + "timestamp": timestamp, + "sender": { + "name": sender_name, + "user_id": sender_user_id, + "is_bot": False, + }, + "virtual_mode": current_virtual_config.enabled if current_virtual_config else False, + } + ) + + # 创建麦麦消息格式 + message_data = create_message_data( + content=content, + user_id=user_id, + user_name=current_user_name, + message_id=message_id, + is_at_bot=True, + virtual_config=current_virtual_config, + ) + + try: + # 显示正在输入状态 + await chat_manager.broadcast( + { + "type": "typing", + "is_typing": True, + } + ) + + # 调用麦麦的消息处理 + await chat_bot.message_process(message_data) + + except Exception as e: + logger.error(f"处理消息时出错: {e}") + await chat_manager.send_message( + session_id, + { + "type": "error", + "content": f"处理消息时出错: {str(e)}", + "timestamp": time.time(), + }, + ) + finally: + await chat_manager.broadcast( + { + "type": "typing", + "is_typing": False, + } + ) + + elif data.get("type") == "ping": + await chat_manager.send_message( + session_id, + { + "type": "pong", + "timestamp": time.time(), + }, + ) + + elif data.get("type") == "update_nickname": + # 允许用户更新昵称 + if new_name := data.get("user_name", "").strip(): + current_user_name = new_name + await chat_manager.send_message( + session_id, + { + "type": "nickname_updated", + "user_name": current_user_name, + "timestamp": time.time(), + }, + ) + + elif data.get("type") == "set_virtual_identity": + # 设置或更新虚拟身份配置 + virtual_data = data.get("config", {}) + if virtual_data.get("enabled"): + # 验证必要字段 + if not virtual_data.get("platform") or not virtual_data.get("person_id"): + await chat_manager.send_message( + session_id, + { + "type": "error", + "content": "虚拟身份配置缺少必要字段: platform 和 person_id", + "timestamp": time.time(), + }, + ) + continue + + # 获取用户信息 + try: + person = PersonInfo.get_or_none(PersonInfo.person_id == virtual_data.get("person_id")) + if not person: + await chat_manager.send_message( + session_id, + { + "type": "error", + "content": f"找不到用户: {virtual_data.get('person_id')}", + "timestamp": time.time(), + }, + ) + continue + + # 生成虚拟群 ID + custom_group_id = virtual_data.get("group_id") + if custom_group_id: + group_id = f"{VIRTUAL_GROUP_ID_PREFIX}{custom_group_id}" + else: + group_id = f"{VIRTUAL_GROUP_ID_PREFIX}{session_id[:8]}" + + current_virtual_config = VirtualIdentityConfig( + enabled=True, + platform=person.platform, + person_id=person.person_id, + user_id=person.user_id, + user_nickname=person.person_name or person.nickname or person.user_id, + group_id=group_id, + group_name=virtual_data.get("group_name", "WebUI虚拟群聊"), + ) + + # 发送虚拟身份已激活的消息 + await chat_manager.send_message( + session_id, + { + "type": "virtual_identity_set", + "config": { + "enabled": True, + "platform": current_virtual_config.platform, + "user_id": current_virtual_config.user_id, + "user_nickname": current_virtual_config.user_nickname, + "group_id": current_virtual_config.group_id, + "group_name": current_virtual_config.group_name, + }, + "timestamp": time.time(), + }, + ) + + # 加载虚拟群的历史记录 + virtual_history = chat_history.get_history(50, current_virtual_config.group_id) + await chat_manager.send_message( + session_id, + { + "type": "history", + "messages": virtual_history, + "group_id": current_virtual_config.group_id, + }, + ) + + # 发送系统消息 + await chat_manager.send_message( + session_id, + { + "type": "system", + "content": f"已切换到虚拟身份模式：以 {current_virtual_config.user_nickname} 的身份在「{current_virtual_config.group_name}」与 {global_config.bot.nickname} 对话", + "timestamp": time.time(), + }, + ) + + except Exception as e: + logger.error(f"设置虚拟身份失败: {e}") + await chat_manager.send_message( + session_id, + { + "type": "error", + "content": f"设置虚拟身份失败: {str(e)}", + "timestamp": time.time(), + }, + ) + else: + # 禁用虚拟身份模式 + current_virtual_config = None + await chat_manager.send_message( + session_id, + { + "type": "virtual_identity_set", + "config": {"enabled": False}, + "timestamp": time.time(), + }, + ) + + # 重新加载默认聊天室历史 + default_history = chat_history.get_history(50, WEBUI_CHAT_GROUP_ID) + await chat_manager.send_message( + session_id, + { + "type": "history", + "messages": default_history, + "group_id": WEBUI_CHAT_GROUP_ID, + }, + ) + + await chat_manager.send_message( + session_id, + { + "type": "system", + "content": "已切换回 WebUI 独立用户模式", + "timestamp": time.time(), + }, + ) + + except WebSocketDisconnect: + logger.info(f"WebSocket 断开: session={session_id}, user={user_id}") + except Exception as e: + logger.error(f"WebSocket 错误: {e}") + finally: + chat_manager.disconnect(session_id, user_id) + + +@router.get("/info") +async def get_chat_info(_auth: bool = Depends(require_auth)): + """获取聊天室信息""" + return { + "bot_name": global_config.bot.nickname, + "platform": WEBUI_CHAT_PLATFORM, + "group_id": WEBUI_CHAT_GROUP_ID, + "active_sessions": len(chat_manager.active_connections), + } + + +def get_webui_chat_broadcaster() -> tuple: + """获取 WebUI 聊天广播器，供外部模块使用 + + Returns: + (chat_manager, WEBUI_CHAT_PLATFORM) 元组 + """ + return (chat_manager, WEBUI_CHAT_PLATFORM) diff --git a/src/webui/config_routes.py b/src/webui/config_routes.py index 84c660ae..6a028927 100644 --- a/src/webui/config_routes.py +++ b/src/webui/config_routes.py @@ -4,11 +4,13 @@ import os import tomlkit -from fastapi import APIRouter, HTTPException, Body -from typing import Any +from fastapi import APIRouter, HTTPException, Body, Depends, Cookie, Header +from typing import Any, Annotated, Optional from src.common.logger import get_logger -from src.config.config import Config, APIAdapterConfig, CONFIG_DIR +from src.webui.auth import verify_auth_token_from_cookie_or_header +from src.common.toml_utils import save_toml_with_format, _update_toml_doc +from src.config.config import Config, APIAdapterConfig, CONFIG_DIR, PROJECT_ROOT from src.config.official_configs import ( BotConfig, PersonalityConfig, @@ -28,9 +30,7 @@ from src.config.official_configs import ( ToolConfig, MemoryConfig, DebugConfig, - MoodConfig, VoiceConfig, - JargonConfig, ) from src.config.api_ada_configs import ( ModelTaskConfig, @@ -41,48 +41,28 @@ from src.webui.config_schema import ConfigSchemaGenerator logger = get_logger("webui") +# 模块级别的类型别名（解决 B008 ruff 错误） +ConfigBody = Annotated[dict[str, Any], Body()] +SectionBody = Annotated[Any, Body()] +RawContentBody = Annotated[str, Body(embed=True)] +PathBody = Annotated[dict[str, str], Body()] + router = APIRouter(prefix="/config", tags=["config"]) -# ===== 辅助函数 ===== - - -def _update_dict_preserve_comments(target: Any, source: Any) -> None: - """ - 递归合并字典，保留 target 中的注释和格式 - 将 source 的值更新到 target 中（仅更新已存在的键） - - Args: - target: 目标字典（tomlkit 对象，包含注释） - source: 源字典（普通 dict 或 list） - """ - # 如果 source 是列表，直接替换（数组表没有注释保留的意义） - if isinstance(source, list): - return # 调用者需要直接赋值 - - # 如果都是字典，递归合并 - if isinstance(source, dict) and isinstance(target, dict): - for key, value in source.items(): - if key == "version": - continue # 跳过版本号 - if key in target: - target_value = target[key] - # 递归处理嵌套字典 - if isinstance(value, dict) and isinstance(target_value, dict): - _update_dict_preserve_comments(target_value, value) - else: - # 使用 tomlkit.item 保持类型 - try: - target[key] = tomlkit.item(value) - except (TypeError, ValueError): - target[key] = value +def require_auth( + maibot_session: Optional[str] = Cookie(None), + authorization: Optional[str] = Header(None), +) -> bool: + """认证依赖：验证用户是否已登录""" + return verify_auth_token_from_cookie_or_header(maibot_session, authorization) # ===== 架构获取接口 ===== @router.get("/schema/bot") -async def get_bot_config_schema(): +async def get_bot_config_schema(_auth: bool = Depends(require_auth)): """获取麦麦主程序配置架构""" try: # Config 类包含所有子配置 @@ -90,25 +70,25 @@ async def get_bot_config_schema(): return {"success": True, "schema": schema} except Exception as e: logger.error(f"获取配置架构失败: {e}") - raise HTTPException(status_code=500, detail=f"获取配置架构失败: {str(e)}") + raise HTTPException(status_code=500, detail=f"获取配置架构失败: {str(e)}") from e @router.get("/schema/model") -async def get_model_config_schema(): +async def get_model_config_schema(_auth: bool = Depends(require_auth)): """获取模型配置架构（包含提供商和模型任务配置）""" try: schema = ConfigSchemaGenerator.generate_config_schema(APIAdapterConfig) return {"success": True, "schema": schema} except Exception as e: logger.error(f"获取模型配置架构失败: {e}") - raise HTTPException(status_code=500, detail=f"获取模型配置架构失败: {str(e)}") + raise HTTPException(status_code=500, detail=f"获取模型配置架构失败: {str(e)}") from e # ===== 子配置架构获取接口 ===== @router.get("/schema/section/{section_name}") -async def get_config_section_schema(section_name: str): +async def get_config_section_schema(section_name: str, _auth: bool = Depends(require_auth)): """ 获取指定配置节的架构 @@ -131,7 +111,6 @@ async def get_config_section_schema(section_name: str): - tool: ToolConfig - memory: MemoryConfig - debug: DebugConfig - - mood: MoodConfig - voice: VoiceConfig - jargon: JargonConfig - model_task_config: ModelTaskConfig @@ -157,9 +136,7 @@ async def get_config_section_schema(section_name: str): "tool": ToolConfig, "memory": MemoryConfig, "debug": DebugConfig, - "mood": MoodConfig, "voice": VoiceConfig, - "jargon": JargonConfig, "model_task_config": ModelTaskConfig, "api_provider": APIProvider, "model_info": ModelInfo, @@ -174,14 +151,14 @@ async def get_config_section_schema(section_name: str): return {"success": True, "schema": schema} except Exception as e: logger.error(f"获取配置节架构失败: {e}") - raise HTTPException(status_code=500, detail=f"获取配置节架构失败: {str(e)}") + raise HTTPException(status_code=500, detail=f"获取配置节架构失败: {str(e)}") from e # ===== 配置读取接口 ===== @router.get("/bot") -async def get_bot_config(): +async def get_bot_config(_auth: bool = Depends(require_auth)): """获取麦麦主程序配置""" try: config_path = os.path.join(CONFIG_DIR, "bot_config.toml") @@ -196,11 +173,11 @@ async def get_bot_config(): raise except Exception as e: logger.error(f"读取配置文件失败: {e}") - raise HTTPException(status_code=500, detail=f"读取配置文件失败: {str(e)}") + raise HTTPException(status_code=500, detail=f"读取配置文件失败: {str(e)}") from e @router.get("/model") -async def get_model_config(): +async def get_model_config(_auth: bool = Depends(require_auth)): """获取模型配置（包含提供商和模型任务配置）""" try: config_path = os.path.join(CONFIG_DIR, "model_config.toml") @@ -215,26 +192,25 @@ async def get_model_config(): raise except Exception as e: logger.error(f"读取配置文件失败: {e}") - raise HTTPException(status_code=500, detail=f"读取配置文件失败: {str(e)}") + raise HTTPException(status_code=500, detail=f"读取配置文件失败: {str(e)}") from e # ===== 配置更新接口 ===== @router.post("/bot") -async def update_bot_config(config_data: dict[str, Any] = Body(...)): +async def update_bot_config(config_data: ConfigBody, _auth: bool = Depends(require_auth)): """更新麦麦主程序配置""" try: # 验证配置数据 try: Config.from_dict(config_data) except Exception as e: - raise HTTPException(status_code=400, detail=f"配置数据验证失败: {str(e)}") + raise HTTPException(status_code=400, detail=f"配置数据验证失败: {str(e)}") from e - # 保存配置文件 + # 保存配置文件（自动保留注释和格式） config_path = os.path.join(CONFIG_DIR, "bot_config.toml") - with open(config_path, "w", encoding="utf-8") as f: - tomlkit.dump(config_data, f) + save_toml_with_format(config_data, config_path) logger.info("麦麦主程序配置已更新") return {"success": True, "message": "配置已保存"} @@ -242,23 +218,22 @@ async def update_bot_config(config_data: dict[str, Any] = Body(...)): raise except Exception as e: logger.error(f"保存配置文件失败: {e}") - raise HTTPException(status_code=500, detail=f"保存配置文件失败: {str(e)}") + raise HTTPException(status_code=500, detail=f"保存配置文件失败: {str(e)}") from e @router.post("/model") -async def update_model_config(config_data: dict[str, Any] = Body(...)): +async def update_model_config(config_data: ConfigBody, _auth: bool = Depends(require_auth)): """更新模型配置""" try: # 验证配置数据 try: APIAdapterConfig.from_dict(config_data) except Exception as e: - raise HTTPException(status_code=400, detail=f"配置数据验证失败: {str(e)}") + raise HTTPException(status_code=400, detail=f"配置数据验证失败: {str(e)}") from e - # 保存配置文件 + # 保存配置文件（自动保留注释和格式） config_path = os.path.join(CONFIG_DIR, "model_config.toml") - with open(config_path, "w", encoding="utf-8") as f: - tomlkit.dump(config_data, f) + save_toml_with_format(config_data, config_path) logger.info("模型配置已更新") return {"success": True, "message": "配置已保存"} @@ -266,14 +241,14 @@ async def update_model_config(config_data: dict[str, Any] = Body(...)): raise except Exception as e: logger.error(f"保存配置文件失败: {e}") - raise HTTPException(status_code=500, detail=f"保存配置文件失败: {str(e)}") + raise HTTPException(status_code=500, detail=f"保存配置文件失败: {str(e)}") from e # ===== 配置节更新接口 ===== @router.post("/bot/section/{section_name}") -async def update_bot_config_section(section_name: str, section_data: Any = Body(...)): +async def update_bot_config_section(section_name: str, section_data: SectionBody, _auth: bool = Depends(require_auth)): """更新麦麦主程序配置的指定节（保留注释和格式）""" try: # 读取现有配置 @@ -295,7 +270,7 @@ async def update_bot_config_section(section_name: str, section_data: Any = Body( config_data[section_name] = section_data elif isinstance(section_data, dict) and isinstance(config_data[section_name], dict): # 字典递归合并 - _update_dict_preserve_comments(config_data[section_name], section_data) + _update_toml_doc(config_data[section_name], section_data) else: # 其他类型直接替换 config_data[section_name] = section_data @@ -304,11 +279,10 @@ async def update_bot_config_section(section_name: str, section_data: Any = Body( try: Config.from_dict(config_data) except Exception as e: - raise HTTPException(status_code=400, detail=f"配置数据验证失败: {str(e)}") + raise HTTPException(status_code=400, detail=f"配置数据验证失败: {str(e)}") from e - # 保存配置（tomlkit.dump 会保留注释） - with open(config_path, "w", encoding="utf-8") as f: - tomlkit.dump(config_data, f) + # 保存配置（格式化数组为多行，保留注释） + save_toml_with_format(config_data, config_path) logger.info(f"配置节 '{section_name}' 已更新（保留注释）") return {"success": True, "message": f"配置节 '{section_name}' 已保存"} @@ -316,14 +290,14 @@ async def update_bot_config_section(section_name: str, section_data: Any = Body( raise except Exception as e: logger.error(f"更新配置节失败: {e}") - raise HTTPException(status_code=500, detail=f"更新配置节失败: {str(e)}") + raise HTTPException(status_code=500, detail=f"更新配置节失败: {str(e)}") from e # ===== 原始 TOML 文件操作接口 ===== @router.get("/bot/raw") -async def get_bot_config_raw(): +async def get_bot_config_raw(_auth: bool = Depends(require_auth)): """获取麦麦主程序配置的原始 TOML 内容""" try: config_path = os.path.join(CONFIG_DIR, "bot_config.toml") @@ -338,24 +312,24 @@ async def get_bot_config_raw(): raise except Exception as e: logger.error(f"读取配置文件失败: {e}") - raise HTTPException(status_code=500, detail=f"读取配置文件失败: {str(e)}") + raise HTTPException(status_code=500, detail=f"读取配置文件失败: {str(e)}") from e @router.post("/bot/raw") -async def update_bot_config_raw(raw_content: str = Body(..., embed=True)): +async def update_bot_config_raw(raw_content: RawContentBody, _auth: bool = Depends(require_auth)): """更新麦麦主程序配置（直接保存原始 TOML 内容，会先验证格式）""" try: # 验证 TOML 格式 try: config_data = tomlkit.loads(raw_content) except Exception as e: - raise HTTPException(status_code=400, detail=f"TOML 格式错误: {str(e)}") + raise HTTPException(status_code=400, detail=f"TOML 格式错误: {str(e)}") from e # 验证配置数据结构 try: Config.from_dict(config_data) except Exception as e: - raise HTTPException(status_code=400, detail=f"配置数据验证失败: {str(e)}") + raise HTTPException(status_code=400, detail=f"配置数据验证失败: {str(e)}") from e # 保存配置文件 config_path = os.path.join(CONFIG_DIR, "bot_config.toml") @@ -368,11 +342,13 @@ async def update_bot_config_raw(raw_content: str = Body(..., embed=True)): raise except Exception as e: logger.error(f"保存配置文件失败: {e}") - raise HTTPException(status_code=500, detail=f"保存配置文件失败: {str(e)}") + raise HTTPException(status_code=500, detail=f"保存配置文件失败: {str(e)}") from e @router.post("/model/section/{section_name}") -async def update_model_config_section(section_name: str, section_data: Any = Body(...)): +async def update_model_config_section( + section_name: str, section_data: SectionBody, _auth: bool = Depends(require_auth) +): """更新模型配置的指定节（保留注释和格式）""" try: # 读取现有配置 @@ -394,7 +370,7 @@ async def update_model_config_section(section_name: str, section_data: Any = Bod config_data[section_name] = section_data elif isinstance(section_data, dict) and isinstance(config_data[section_name], dict): # 字典递归合并 - _update_dict_preserve_comments(config_data[section_name], section_data) + _update_toml_doc(config_data[section_name], section_data) else: # 其他类型直接替换 config_data[section_name] = section_data @@ -403,11 +379,21 @@ async def update_model_config_section(section_name: str, section_data: Any = Bod try: APIAdapterConfig.from_dict(config_data) except Exception as e: - raise HTTPException(status_code=400, detail=f"配置数据验证失败: {str(e)}") + logger.error(f"配置数据验证失败，详细错误: {str(e)}") + # 特殊处理：如果是更新 api_providers，检查是否有模型引用了已删除的provider + if section_name == "api_providers" and "api_provider" in str(e): + provider_names = {p.get("name") for p in section_data if isinstance(p, dict)} + models = config_data.get("models", []) + orphaned_models = [ + m.get("name") for m in models if isinstance(m, dict) and m.get("api_provider") not in provider_names + ] + if orphaned_models: + error_msg = f"以下模型引用了已删除的提供商: {', '.join(orphaned_models)}。请先在模型管理页面删除这些模型，或重新分配它们的提供商。" + raise HTTPException(status_code=400, detail=error_msg) from e + raise HTTPException(status_code=400, detail=f"配置数据验证失败: {str(e)}") from e - # 保存配置（tomlkit.dump 会保留注释） - with open(config_path, "w", encoding="utf-8") as f: - tomlkit.dump(config_data, f) + # 保存配置（格式化数组为多行，保留注释） + save_toml_with_format(config_data, config_path) logger.info(f"配置节 '{section_name}' 已更新（保留注释）") return {"success": True, "message": f"配置节 '{section_name}' 已保存"} @@ -415,14 +401,46 @@ async def update_model_config_section(section_name: str, section_data: Any = Bod raise except Exception as e: logger.error(f"更新配置节失败: {e}") - raise HTTPException(status_code=500, detail=f"更新配置节失败: {str(e)}") + raise HTTPException(status_code=500, detail=f"更新配置节失败: {str(e)}") from e # ===== 适配器配置管理接口 ===== +def _normalize_adapter_path(path: str) -> str: + """将路径转换为绝对路径（如果是相对路径，则相对于项目根目录）""" + if not path: + return path + + # 如果已经是绝对路径，直接返回 + if os.path.isabs(path): + return path + + # 相对路径，转换为相对于项目根目录的绝对路径 + return os.path.normpath(os.path.join(PROJECT_ROOT, path)) + + +def _to_relative_path(path: str) -> str: + """尝试将绝对路径转换为相对于项目根目录的相对路径，如果无法转换则返回原路径""" + if not path or not os.path.isabs(path): + return path + + try: + # 尝试获取相对路径 + rel_path = os.path.relpath(path, PROJECT_ROOT) + # 如果相对路径不是以 .. 开头（说明文件在项目目录内），则返回相对路径 + if not rel_path.startswith(".."): + return rel_path + except (ValueError, TypeError): + # 在 Windows 上，如果路径在不同驱动器，relpath 会抛出 ValueError + pass + + # 无法转换为相对路径，返回绝对路径 + return path + + @router.get("/adapter-config/path") -async def get_adapter_config_path(): +async def get_adapter_config_path(_auth: bool = Depends(require_auth)): """获取保存的适配器配置文件路径""" try: # 从 data/webui.json 读取路径偏好 @@ -431,6 +449,7 @@ async def get_adapter_config_path(): return {"success": True, "path": None} import json + with open(webui_data_path, "r", encoding="utf-8") as f: webui_data = json.load(f) @@ -438,22 +457,29 @@ async def get_adapter_config_path(): if not adapter_config_path: return {"success": True, "path": None} + # 将路径规范化为绝对路径 + abs_path = _normalize_adapter_path(adapter_config_path) + # 检查文件是否存在并返回最后修改时间 - if os.path.exists(adapter_config_path): + if os.path.exists(abs_path): import datetime - mtime = os.path.getmtime(adapter_config_path) + + mtime = os.path.getmtime(abs_path) last_modified = datetime.datetime.fromtimestamp(mtime).isoformat() - return {"success": True, "path": adapter_config_path, "lastModified": last_modified} + # 返回相对路径（如果可能） + display_path = _to_relative_path(abs_path) + return {"success": True, "path": display_path, "lastModified": last_modified} else: + # 文件不存在，返回原路径 return {"success": True, "path": adapter_config_path, "lastModified": None} except Exception as e: logger.error(f"获取适配器配置路径失败: {e}") - raise HTTPException(status_code=500, detail=f"获取配置路径失败: {str(e)}") + raise HTTPException(status_code=500, detail=f"获取配置路径失败: {str(e)}") from e @router.post("/adapter-config/path") -async def save_adapter_config_path(data: dict[str, str] = Body(...)): +async def save_adapter_config_path(data: PathBody, _auth: bool = Depends(require_auth)): """保存适配器配置文件路径偏好""" try: path = data.get("path") @@ -471,55 +497,64 @@ async def save_adapter_config_path(data: dict[str, str] = Body(...)): else: webui_data = {} + # 将路径规范化为绝对路径 + abs_path = _normalize_adapter_path(path) + + # 尝试转换为相对路径保存（如果文件在项目目录内） + save_path = _to_relative_path(abs_path) + # 更新路径 - webui_data["adapter_config_path"] = path + webui_data["adapter_config_path"] = save_path # 保存 os.makedirs("data", exist_ok=True) with open(webui_data_path, "w", encoding="utf-8") as f: json.dump(webui_data, f, ensure_ascii=False, indent=2) - logger.info(f"适配器配置路径已保存: {path}") + logger.info(f"适配器配置路径已保存: {save_path}（绝对路径: {abs_path}）") return {"success": True, "message": "路径已保存"} except HTTPException: raise except Exception as e: logger.error(f"保存适配器配置路径失败: {e}") - raise HTTPException(status_code=500, detail=f"保存路径失败: {str(e)}") + raise HTTPException(status_code=500, detail=f"保存路径失败: {str(e)}") from e @router.get("/adapter-config") -async def get_adapter_config(path: str): +async def get_adapter_config(path: str, _auth: bool = Depends(require_auth)): """从指定路径读取适配器配置文件""" try: if not path: raise HTTPException(status_code=400, detail="路径参数不能为空") + # 将路径规范化为绝对路径 + abs_path = _normalize_adapter_path(path) + # 检查文件是否存在 - if not os.path.exists(path): + if not os.path.exists(abs_path): raise HTTPException(status_code=404, detail=f"配置文件不存在: {path}") # 检查文件扩展名 - if not path.endswith(".toml"): + if not abs_path.endswith(".toml"): raise HTTPException(status_code=400, detail="只支持 .toml 格式的配置文件") # 读取文件内容 - with open(path, "r", encoding="utf-8") as f: + with open(abs_path, "r", encoding="utf-8") as f: content = f.read() - logger.info(f"已读取适配器配置: {path}") + logger.info(f"已读取适配器配置: {path} (绝对路径: {abs_path})") return {"success": True, "content": content} except HTTPException: raise except Exception as e: logger.error(f"读取适配器配置失败: {e}") - raise HTTPException(status_code=500, detail=f"读取配置失败: {str(e)}") + raise HTTPException(status_code=500, detail=f"读取配置失败: {str(e)}") from e @router.post("/adapter-config") -async def save_adapter_config(data: dict[str, str] = Body(...)): +async def save_adapter_config(data: PathBody, _auth: bool = Depends(require_auth)): """保存适配器配置到指定路径""" try: path = data.get("path") @@ -530,30 +565,33 @@ async def save_adapter_config(data: dict[str, str] = Body(...)): if content is None: raise HTTPException(status_code=400, detail="配置内容不能为空") + # 将路径规范化为绝对路径 + abs_path = _normalize_adapter_path(path) + # 检查文件扩展名 - if not path.endswith(".toml"): + if not abs_path.endswith(".toml"): raise HTTPException(status_code=400, detail="只支持 .toml 格式的配置文件") # 验证 TOML 格式 try: - import toml - toml.loads(content) + tomlkit.loads(content) except Exception as e: - raise HTTPException(status_code=400, detail=f"TOML 格式错误: {str(e)}") + raise HTTPException(status_code=400, detail=f"TOML 格式错误: {str(e)}") from e # 确保目录存在 - os.makedirs(os.path.dirname(path) if os.path.dirname(path) else ".", exist_ok=True) + dir_path = os.path.dirname(abs_path) + if dir_path: + os.makedirs(dir_path, exist_ok=True) # 保存文件 - with open(path, "w", encoding="utf-8") as f: + with open(abs_path, "w", encoding="utf-8") as f: f.write(content) - logger.info(f"适配器配置已保存: {path}") + logger.info(f"适配器配置已保存: {path} (绝对路径: {abs_path})") return {"success": True, "message": "配置已保存"} except HTTPException: raise except Exception as e: logger.error(f"保存适配器配置失败: {e}") - raise HTTPException(status_code=500, detail=f"保存配置失败: {str(e)}") - + raise HTTPException(status_code=500, detail=f"保存配置失败: {str(e)}") from e diff --git a/src/webui/config_schema.py b/src/webui/config_schema.py index c1608bc4..5c5763fa 100644 --- a/src/webui/config_schema.py +++ b/src/webui/config_schema.py @@ -117,7 +117,7 @@ class ConfigSchemaGenerator: if next_line.startswith('"""') or next_line.startswith("'''"): # 单行文档字符串 if next_line.count('"""') == 2 or next_line.count("'''") == 2: - description_lines.append(next_line.strip('"""').strip("'''").strip()) + description_lines.append(next_line.replace('"""', "").replace("'''", "").strip()) else: # 多行文档字符串 quote = '"""' if next_line.startswith('"""') else "'''" @@ -135,7 +135,7 @@ class ConfigSchemaGenerator: next_line = lines[i + 1].strip() if next_line.startswith('"""') or next_line.startswith("'''"): if next_line.count('"""') == 2 or next_line.count("'''") == 2: - description_lines.append(next_line.strip('"""').strip("'''").strip()) + description_lines.append(next_line.replace('"""', "").replace("'''", "").strip()) else: quote = '"""' if next_line.startswith('"""') else "'''" description_lines.append(next_line.strip(quote).strip()) @@ -199,13 +199,13 @@ class ConfigSchemaGenerator: return FieldType.ARRAY, None, items # 处理基本类型 - if field_type is bool or field_type == bool: + if field_type is bool: return FieldType.BOOLEAN, None, None - elif field_type is int or field_type == int: + elif field_type is int: return FieldType.INTEGER, None, None - elif field_type is float or field_type == float: + elif field_type is float: return FieldType.NUMBER, None, None - elif field_type is str or field_type == str: + elif field_type is str: return FieldType.STRING, None, None elif field_type is dict or origin is dict: return FieldType.OBJECT, None, None @@ -296,7 +296,6 @@ class ConfigSchemaGenerator: "plan_style", "visual_style", "private_plan_style", - "emotion_style", "reaction", "filtration_prompt", ]: diff --git a/src/webui/emoji_routes.py b/src/webui/emoji_routes.py index 471eb6d7..90b2d60b 100644 --- a/src/webui/emoji_routes.py +++ b/src/webui/emoji_routes.py @@ -1,18 +1,176 @@ """表情包管理 API 路由""" -from fastapi import APIRouter, HTTPException, Header, Query -from fastapi.responses import FileResponse +from fastapi import APIRouter, HTTPException, Header, Query, UploadFile, File, Form, Cookie +from fastapi.responses import FileResponse, JSONResponse from pydantic import BaseModel -from typing import Optional, List +from typing import Optional, List, Annotated from src.common.logger import get_logger from src.common.database.database_model import Emoji from .token_manager import get_token_manager -import json +from .auth import verify_auth_token_from_cookie_or_header import time import os +import hashlib +from PIL import Image +import io +from pathlib import Path +import threading +import asyncio +from concurrent.futures import ThreadPoolExecutor logger = get_logger("webui.emoji") +# ==================== 缩略图缓存配置 ==================== +# 缩略图缓存目录 +THUMBNAIL_CACHE_DIR = Path("data/emoji_thumbnails") +# 缩略图尺寸 (宽, 高) +THUMBNAIL_SIZE = (200, 200) +# 缩略图质量 (WebP 格式, 1-100) +THUMBNAIL_QUALITY = 80 +# 缓存锁，防止并发生成同一缩略图 +_thumbnail_locks: dict[str, threading.Lock] = {} +_locks_lock = threading.Lock() +# 缩略图生成专用线程池（避免阻塞事件循环） +_thumbnail_executor = ThreadPoolExecutor(max_workers=2, thread_name_prefix="thumbnail") +# 正在生成中的缩略图哈希集合（防止重复提交任务） +_generating_thumbnails: set[str] = set() +_generating_lock = threading.Lock() + + +def _get_thumbnail_lock(file_hash: str) -> threading.Lock: + """获取指定文件哈希的锁，用于防止并发生成同一缩略图""" + with _locks_lock: + if file_hash not in _thumbnail_locks: + _thumbnail_locks[file_hash] = threading.Lock() + return _thumbnail_locks[file_hash] + + +def _background_generate_thumbnail(source_path: str, file_hash: str) -> None: + """ + 后台生成缩略图（在线程池中执行） + + 生成完成后自动从 generating 集合中移除 + """ + try: + _generate_thumbnail(source_path, file_hash) + except Exception as e: + logger.warning(f"后台生成缩略图失败 {file_hash}: {e}") + finally: + with _generating_lock: + _generating_thumbnails.discard(file_hash) + + +def _ensure_thumbnail_cache_dir() -> Path: + """确保缩略图缓存目录存在""" + THUMBNAIL_CACHE_DIR.mkdir(parents=True, exist_ok=True) + return THUMBNAIL_CACHE_DIR + + +def _get_thumbnail_cache_path(file_hash: str) -> Path: + """获取缩略图缓存路径""" + return THUMBNAIL_CACHE_DIR / f"{file_hash}.webp" + + +def _generate_thumbnail(source_path: str, file_hash: str) -> Path: + """ + 生成缩略图并保存到缓存目录 + + Args: + source_path: 原图路径 + file_hash: 文件哈希值，用作缓存文件名 + + Returns: + 缩略图路径 + + Features: + - GIF: 提取第一帧作为缩略图 + - 所有格式统一转为 WebP + - 保持宽高比缩放 + """ + _ensure_thumbnail_cache_dir() + cache_path = _get_thumbnail_cache_path(file_hash) + + # 使用锁防止并发生成同一缩略图 + lock = _get_thumbnail_lock(file_hash) + with lock: + # 双重检查，可能在等待锁时已被其他线程生成 + if cache_path.exists(): + return cache_path + + try: + with Image.open(source_path) as img: + # GIF 处理：提取第一帧 + if hasattr(img, "n_frames") and img.n_frames > 1: + img.seek(0) # 确保在第一帧 + + # 转换为 RGB/RGBA（WebP 支持透明度） + if img.mode in ("P", "PA"): + # 调色板模式转换为 RGBA 以保留透明度 + img = img.convert("RGBA") + elif img.mode == "LA": + img = img.convert("RGBA") + elif img.mode not in ("RGB", "RGBA"): + img = img.convert("RGB") + + # 创建缩略图（保持宽高比） + img.thumbnail(THUMBNAIL_SIZE, Image.Resampling.LANCZOS) + + # 保存为 WebP 格式 + img.save(cache_path, "WEBP", quality=THUMBNAIL_QUALITY, method=6) + + logger.debug(f"生成缩略图: {file_hash} -> {cache_path}") + + except Exception as e: + logger.warning(f"生成缩略图失败 {file_hash}: {e}，将返回原图") + # 生成失败时不创建缓存文件，下次会重试 + raise + + return cache_path + + +def cleanup_orphaned_thumbnails() -> tuple[int, int]: + """ + 清理孤立的缩略图缓存（原图已不存在的缩略图） + + Returns: + (清理数量, 保留数量) + """ + if not THUMBNAIL_CACHE_DIR.exists(): + return 0, 0 + + # 获取所有表情包的哈希值 + valid_hashes = set() + for emoji in Emoji.select(Emoji.emoji_hash): + valid_hashes.add(emoji.emoji_hash) + + cleaned = 0 + kept = 0 + + for cache_file in THUMBNAIL_CACHE_DIR.glob("*.webp"): + file_hash = cache_file.stem + if file_hash not in valid_hashes: + try: + cache_file.unlink() + cleaned += 1 + logger.debug(f"清理孤立缩略图: {cache_file.name}") + except Exception as e: + logger.warning(f"清理缩略图失败 {cache_file.name}: {e}") + else: + kept += 1 + + if cleaned > 0: + logger.info(f"清理孤立缩略图: 删除 {cleaned} 个，保留 {kept} 个") + + return cleaned, kept + + +# 模块级别的类型别名（解决 B008 ruff 错误） +EmojiFile = Annotated[UploadFile, File(description="表情包图片文件")] +EmojiFiles = Annotated[List[UploadFile], File(description="多个表情包图片文件")] +DescriptionForm = Annotated[str, Form(description="表情包描述")] +EmotionForm = Annotated[str, Form(description="情感标签，多个用逗号分隔")] +IsRegisteredForm = Annotated[bool, Form(description="是否直接注册")] + # 创建路由器 router = APIRouter(prefix="/emoji", tags=["Emoji"]) @@ -92,18 +250,12 @@ class BatchDeleteResponse(BaseModel): failed_ids: List[int] = [] -def verify_auth_token(authorization: Optional[str]) -> bool: - """验证认证 Token""" - if not authorization or not authorization.startswith("Bearer "): - raise HTTPException(status_code=401, detail="未提供有效的认证信息") - - token = authorization.replace("Bearer ", "") - token_manager = get_token_manager() - - if not token_manager.verify_token(token): - raise HTTPException(status_code=401, detail="Token 无效或已过期") - - return True +def verify_auth_token( + maibot_session: Optional[str] = None, + authorization: Optional[str] = None, +) -> bool: + """验证认证 Token，支持 Cookie 和 Header""" + return verify_auth_token_from_cookie_or_header(maibot_session, authorization) def emoji_to_response(emoji: Emoji) -> EmojiResponse: @@ -133,6 +285,9 @@ async def get_emoji_list( is_registered: Optional[bool] = Query(None, description="是否已注册筛选"), is_banned: Optional[bool] = Query(None, description="是否被禁用筛选"), format: Optional[str] = Query(None, description="格式筛选"), + sort_by: Optional[str] = Query("usage_count", description="排序字段"), + sort_order: Optional[str] = Query("desc", description="排序方向"), + maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None), ): """ @@ -145,13 +300,15 @@ async def get_emoji_list( is_registered: 是否已注册筛选 is_banned: 是否被禁用筛选 format: 格式筛选 + sort_by: 排序字段 (usage_count, register_time, record_time, last_used_time) + sort_order: 排序方向 (asc, desc) authorization: Authorization header Returns: 表情包列表 """ try: - verify_auth_token(authorization) + verify_auth_token(maibot_session, authorization) # 构建查询 query = Emoji.select() @@ -172,12 +329,22 @@ async def get_emoji_list( if format: query = query.where(Emoji.format == format) - # 排序：使用次数倒序，然后按记录时间倒序 - from peewee import Case + # 排序字段映射 + sort_field_map = { + "usage_count": Emoji.usage_count, + "register_time": Emoji.register_time, + "record_time": Emoji.record_time, + "last_used_time": Emoji.last_used_time, + } - query = query.order_by( - Emoji.usage_count.desc(), Case(None, [(Emoji.record_time.is_null(), 1)], 0), Emoji.record_time.desc() - ) + # 获取排序字段，默认使用 usage_count + sort_field = sort_field_map.get(sort_by, Emoji.usage_count) + + # 应用排序 + if sort_order == "asc": + query = query.order_by(sort_field.asc()) + else: + query = query.order_by(sort_field.desc()) # 获取总数 total = query.count() @@ -199,7 +366,9 @@ async def get_emoji_list( @router.get("/{emoji_id}", response_model=EmojiDetailResponse) -async def get_emoji_detail(emoji_id: int, authorization: Optional[str] = Header(None)): +async def get_emoji_detail( + emoji_id: int, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None) +): """ 获取表情包详细信息 @@ -211,7 +380,7 @@ async def get_emoji_detail(emoji_id: int, authorization: Optional[str] = Header( 表情包详细信息 """ try: - verify_auth_token(authorization) + verify_auth_token(maibot_session, authorization) emoji = Emoji.get_or_none(Emoji.id == emoji_id) @@ -228,7 +397,12 @@ async def get_emoji_detail(emoji_id: int, authorization: Optional[str] = Header( @router.patch("/{emoji_id}", response_model=EmojiUpdateResponse) -async def update_emoji(emoji_id: int, request: EmojiUpdateRequest, authorization: Optional[str] = Header(None)): +async def update_emoji( + emoji_id: int, + request: EmojiUpdateRequest, + maibot_session: Optional[str] = Cookie(None), + authorization: Optional[str] = Header(None), +): """ 增量更新表情包（只更新提供的字段） @@ -241,7 +415,7 @@ async def update_emoji(emoji_id: int, request: EmojiUpdateRequest, authorization 更新结果 """ try: - verify_auth_token(authorization) + verify_auth_token(maibot_session, authorization) emoji = Emoji.get_or_none(Emoji.id == emoji_id) @@ -280,7 +454,9 @@ async def update_emoji(emoji_id: int, request: EmojiUpdateRequest, authorization @router.delete("/{emoji_id}", response_model=EmojiDeleteResponse) -async def delete_emoji(emoji_id: int, authorization: Optional[str] = Header(None)): +async def delete_emoji( + emoji_id: int, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None) +): """ 删除表情包 @@ -292,7 +468,7 @@ async def delete_emoji(emoji_id: int, authorization: Optional[str] = Header(None 删除结果 """ try: - verify_auth_token(authorization) + verify_auth_token(maibot_session, authorization) emoji = Emoji.get_or_none(Emoji.id == emoji_id) @@ -317,7 +493,7 @@ async def delete_emoji(emoji_id: int, authorization: Optional[str] = Header(None @router.get("/stats/summary") -async def get_emoji_stats(authorization: Optional[str] = Header(None)): +async def get_emoji_stats(maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None)): """ 获取表情包统计数据 @@ -328,7 +504,7 @@ async def get_emoji_stats(authorization: Optional[str] = Header(None)): 统计数据 """ try: - verify_auth_token(authorization) + verify_auth_token(maibot_session, authorization) total = Emoji.select().count() registered = Emoji.select().where(Emoji.is_registered).count() @@ -372,7 +548,9 @@ async def get_emoji_stats(authorization: Optional[str] = Header(None)): @router.post("/{emoji_id}/register", response_model=EmojiUpdateResponse) -async def register_emoji(emoji_id: int, authorization: Optional[str] = Header(None)): +async def register_emoji( + emoji_id: int, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None) +): """ 注册表情包（快捷操作） @@ -384,7 +562,7 @@ async def register_emoji(emoji_id: int, authorization: Optional[str] = Header(No 更新结果 """ try: - verify_auth_token(authorization) + verify_auth_token(maibot_session, authorization) emoji = Emoji.get_or_none(Emoji.id == emoji_id) @@ -394,11 +572,9 @@ async def register_emoji(emoji_id: int, authorization: Optional[str] = Header(No if emoji.is_registered: raise HTTPException(status_code=400, detail="该表情包已经注册") - if emoji.is_banned: - raise HTTPException(status_code=400, detail="该表情包已被禁用，无法注册") - - # 注册表情包 + # 注册表情包（如果已封禁，自动解除封禁） emoji.is_registered = True + emoji.is_banned = False # 注册时自动解除封禁 emoji.register_time = time.time() emoji.save() @@ -414,7 +590,9 @@ async def register_emoji(emoji_id: int, authorization: Optional[str] = Header(No @router.post("/{emoji_id}/ban", response_model=EmojiUpdateResponse) -async def ban_emoji(emoji_id: int, authorization: Optional[str] = Header(None)): +async def ban_emoji( + emoji_id: int, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None) +): """ 禁用表情包（快捷操作） @@ -426,7 +604,7 @@ async def ban_emoji(emoji_id: int, authorization: Optional[str] = Header(None)): 更新结果 """ try: - verify_auth_token(authorization) + verify_auth_token(maibot_session, authorization) emoji = Emoji.get_or_none(Emoji.id == emoji_id) @@ -453,28 +631,47 @@ async def ban_emoji(emoji_id: int, authorization: Optional[str] = Header(None)): async def get_emoji_thumbnail( emoji_id: int, token: Optional[str] = Query(None, description="访问令牌"), + maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None), + original: bool = Query(False, description="是否返回原图"), ): """ - 获取表情包缩略图 + 获取表情包缩略图（懒加载生成 + 缓存） Args: emoji_id: 表情包ID - token: 访问令牌（通过 query parameter） + token: 访问令牌（通过 query parameter，用于向后兼容） + maibot_session: Cookie 中的 token authorization: Authorization header + original: 是否返回原图（用于详情页查看原图） Returns: - 表情包图片文件 + 表情包缩略图（WebP 格式）或原图 + + Features: + - 懒加载：首次请求时生成缩略图 + - 缓存：后续请求直接返回缓存 + - GIF 支持：提取第一帧作为缩略图 + - 格式统一：所有缩略图统一为 WebP 格式 """ try: - # 优先使用 query parameter 中的 token（用于 img 标签） - if token: - token_manager = get_token_manager() - if not token_manager.verify_token(token): - raise HTTPException(status_code=401, detail="Token 无效或已过期") - else: - # 如果没有 query token，则验证 Authorization header - verify_auth_token(authorization) + token_manager = get_token_manager() + is_valid = False + + # 1. 优先使用 Cookie + if maibot_session and token_manager.verify_token(maibot_session): + is_valid = True + # 2. 其次使用 query parameter（用于向后兼容 img 标签） + elif token and token_manager.verify_token(token): + is_valid = True + # 3. 最后使用 Authorization header + elif authorization and authorization.startswith("Bearer "): + auth_token = authorization.replace("Bearer ", "") + if token_manager.verify_token(auth_token): + is_valid = True + + if not is_valid: + raise HTTPException(status_code=401, detail="Token 无效或已过期") emoji = Emoji.get_or_none(Emoji.id == emoji_id) @@ -485,19 +682,51 @@ async def get_emoji_thumbnail( if not os.path.exists(emoji.full_path): raise HTTPException(status_code=404, detail="表情包文件不存在") - # 根据格式设置 MIME 类型 - mime_types = { - "png": "image/png", - "jpg": "image/jpeg", - "jpeg": "image/jpeg", - "gif": "image/gif", - "webp": "image/webp", - "bmp": "image/bmp", - } + # 如果请求原图，直接返回原文件 + if original: + mime_types = { + "png": "image/png", + "jpg": "image/jpeg", + "jpeg": "image/jpeg", + "gif": "image/gif", + "webp": "image/webp", + "bmp": "image/bmp", + } + media_type = mime_types.get(emoji.format.lower(), "application/octet-stream") + return FileResponse( + path=emoji.full_path, media_type=media_type, filename=f"{emoji.emoji_hash}.{emoji.format}" + ) - media_type = mime_types.get(emoji.format.lower(), "application/octet-stream") + # 尝试获取或生成缩略图 + cache_path = _get_thumbnail_cache_path(emoji.emoji_hash) - return FileResponse(path=emoji.full_path, media_type=media_type, filename=f"{emoji.emoji_hash}.{emoji.format}") + # 检查缓存是否存在 + if cache_path.exists(): + # 缓存命中，直接返回 + return FileResponse( + path=str(cache_path), media_type="image/webp", filename=f"{emoji.emoji_hash}_thumb.webp" + ) + + # 缓存未命中，触发后台生成并返回 202 + with _generating_lock: + if emoji.emoji_hash not in _generating_thumbnails: + # 标记为正在生成 + _generating_thumbnails.add(emoji.emoji_hash) + # 提交到线程池后台生成 + _thumbnail_executor.submit(_background_generate_thumbnail, emoji.full_path, emoji.emoji_hash) + + # 返回 202 Accepted，告诉前端缩略图正在生成中 + return JSONResponse( + status_code=202, + content={ + "status": "generating", + "message": "缩略图正在生成中，请稍后重试", + "emoji_id": emoji_id, + }, + headers={ + "Retry-After": "1", # 建议 1 秒后重试 + }, + ) except HTTPException: raise @@ -507,7 +736,11 @@ async def get_emoji_thumbnail( @router.post("/batch/delete", response_model=BatchDeleteResponse) -async def batch_delete_emojis(request: BatchDeleteRequest, authorization: Optional[str] = Header(None)): +async def batch_delete_emojis( + request: BatchDeleteRequest, + maibot_session: Optional[str] = Cookie(None), + authorization: Optional[str] = Header(None), +): """ 批量删除表情包 @@ -519,7 +752,7 @@ async def batch_delete_emojis(request: BatchDeleteRequest, authorization: Option 批量删除结果 """ try: - verify_auth_token(authorization) + verify_auth_token(maibot_session, authorization) if not request.emoji_ids: raise HTTPException(status_code=400, detail="未提供要删除的表情包ID") @@ -560,3 +793,519 @@ async def batch_delete_emojis(request: BatchDeleteRequest, authorization: Option except Exception as e: logger.exception(f"批量删除表情包失败: {e}") raise HTTPException(status_code=500, detail=f"批量删除失败: {str(e)}") from e + + +# 表情包存储目录 +EMOJI_REGISTERED_DIR = os.path.join("data", "emoji_registed") + + +class EmojiUploadResponse(BaseModel): + """表情包上传响应""" + + success: bool + message: str + data: Optional[EmojiResponse] = None + + +@router.post("/upload", response_model=EmojiUploadResponse) +async def upload_emoji( + file: EmojiFile, + description: DescriptionForm = "", + emotion: EmotionForm = "", + is_registered: IsRegisteredForm = True, + maibot_session: Optional[str] = Cookie(None), + authorization: Optional[str] = Header(None), +): + """ + 上传并注册表情包 + + Args: + file: 表情包图片文件 (支持 jpg, jpeg, png, gif, webp) + description: 表情包描述 + emotion: 情感标签，多个用逗号分隔 + is_registered: 是否直接注册，默认为 True + authorization: Authorization header + + Returns: + 上传结果和表情包信息 + """ + try: + verify_auth_token(maibot_session, authorization) + + # 验证文件类型 + if not file.content_type: + raise HTTPException(status_code=400, detail="无法识别文件类型") + + allowed_types = ["image/jpeg", "image/png", "image/gif", "image/webp"] + if file.content_type not in allowed_types: + raise HTTPException( + status_code=400, + detail=f"不支持的文件类型: {file.content_type}，支持: {', '.join(allowed_types)}", + ) + + # 读取文件内容 + file_content = await file.read() + + if not file_content: + raise HTTPException(status_code=400, detail="文件内容为空") + + # 验证图片并获取格式 + try: + with Image.open(io.BytesIO(file_content)) as img: + img_format = img.format.lower() if img.format else "png" + # 验证图片可以正常打开 + img.verify() + except Exception as e: + raise HTTPException(status_code=400, detail=f"无效的图片文件: {str(e)}") from e + + # 重新打开图片（verify后需要重新打开） + with Image.open(io.BytesIO(file_content)) as img: + img_format = img.format.lower() if img.format else "png" + + # 计算文件哈希 + emoji_hash = hashlib.md5(file_content).hexdigest() + + # 检查是否已存在相同哈希的表情包 + existing_emoji = Emoji.get_or_none(Emoji.emoji_hash == emoji_hash) + if existing_emoji: + raise HTTPException( + status_code=409, + detail=f"已存在相同的表情包 (ID: {existing_emoji.id})", + ) + + # 确保目录存在 + os.makedirs(EMOJI_REGISTERED_DIR, exist_ok=True) + + # 生成文件名 + timestamp = int(time.time()) + filename = f"emoji_{timestamp}_{emoji_hash[:8]}.{img_format}" + full_path = os.path.join(EMOJI_REGISTERED_DIR, filename) + + # 如果文件已存在，添加随机后缀 + counter = 1 + while os.path.exists(full_path): + filename = f"emoji_{timestamp}_{emoji_hash[:8]}_{counter}.{img_format}" + full_path = os.path.join(EMOJI_REGISTERED_DIR, filename) + counter += 1 + + # 保存文件 + with open(full_path, "wb") as f: + f.write(file_content) + + logger.info(f"表情包文件已保存: {full_path}") + + # 处理情感标签 + emotion_str = ",".join(e.strip() for e in emotion.split(",") if e.strip()) if emotion else "" + + # 创建数据库记录 + current_time = time.time() + emoji = Emoji.create( + full_path=full_path, + format=img_format, + emoji_hash=emoji_hash, + description=description, + emotion=emotion_str, + query_count=0, + is_registered=is_registered, + is_banned=False, + record_time=current_time, + register_time=current_time if is_registered else None, + usage_count=0, + last_used_time=None, + ) + + logger.info(f"表情包已上传并注册: ID={emoji.id}, hash={emoji_hash}") + + return EmojiUploadResponse( + success=True, + message="表情包上传成功" + ("并已注册" if is_registered else ""), + data=emoji_to_response(emoji), + ) + + except HTTPException: + raise + except Exception as e: + logger.exception(f"上传表情包失败: {e}") + raise HTTPException(status_code=500, detail=f"上传失败: {str(e)}") from e + + +@router.post("/batch/upload") +async def batch_upload_emoji( + files: EmojiFiles, + emotion: EmotionForm = "", + is_registered: IsRegisteredForm = True, + maibot_session: Optional[str] = Cookie(None), + authorization: Optional[str] = Header(None), +): + """ + 批量上传表情包 + + Args: + files: 多个表情包图片文件 + emotion: 共用的情感标签 + is_registered: 是否直接注册 + authorization: Authorization header + + Returns: + 批量上传结果 + """ + try: + verify_auth_token(maibot_session, authorization) + + results = { + "success": True, + "total": len(files), + "uploaded": 0, + "failed": 0, + "details": [], + } + + allowed_types = ["image/jpeg", "image/png", "image/gif", "image/webp"] + os.makedirs(EMOJI_REGISTERED_DIR, exist_ok=True) + + for file in files: + try: + # 验证文件类型 + if file.content_type not in allowed_types: + results["failed"] += 1 + results["details"].append( + { + "filename": file.filename, + "success": False, + "error": f"不支持的文件类型: {file.content_type}", + } + ) + continue + + # 读取文件内容 + file_content = await file.read() + + if not file_content: + results["failed"] += 1 + results["details"].append( + { + "filename": file.filename, + "success": False, + "error": "文件内容为空", + } + ) + continue + + # 验证图片 + try: + with Image.open(io.BytesIO(file_content)) as img: + img_format = img.format.lower() if img.format else "png" + except Exception as e: + results["failed"] += 1 + results["details"].append( + { + "filename": file.filename, + "success": False, + "error": f"无效的图片: {str(e)}", + } + ) + continue + + # 计算哈希 + emoji_hash = hashlib.md5(file_content).hexdigest() + + # 检查重复 + if Emoji.get_or_none(Emoji.emoji_hash == emoji_hash): + results["failed"] += 1 + results["details"].append( + { + "filename": file.filename, + "success": False, + "error": "已存在相同的表情包", + } + ) + continue + + # 生成文件名并保存 + timestamp = int(time.time()) + filename = f"emoji_{timestamp}_{emoji_hash[:8]}.{img_format}" + full_path = os.path.join(EMOJI_REGISTERED_DIR, filename) + + counter = 1 + while os.path.exists(full_path): + filename = f"emoji_{timestamp}_{emoji_hash[:8]}_{counter}.{img_format}" + full_path = os.path.join(EMOJI_REGISTERED_DIR, filename) + counter += 1 + + with open(full_path, "wb") as f: + f.write(file_content) + + # 处理情感标签 + emotion_str = ",".join(e.strip() for e in emotion.split(",") if e.strip()) if emotion else "" + + # 创建数据库记录 + current_time = time.time() + emoji = Emoji.create( + full_path=full_path, + format=img_format, + emoji_hash=emoji_hash, + description="", # 批量上传暂不设置描述 + emotion=emotion_str, + query_count=0, + is_registered=is_registered, + is_banned=False, + record_time=current_time, + register_time=current_time if is_registered else None, + usage_count=0, + last_used_time=None, + ) + + results["uploaded"] += 1 + results["details"].append( + { + "filename": file.filename, + "success": True, + "id": emoji.id, + } + ) + + except Exception as e: + results["failed"] += 1 + results["details"].append( + { + "filename": file.filename, + "success": False, + "error": str(e), + } + ) + + results["message"] = f"成功上传 {results['uploaded']} 个，失败 {results['failed']} 个" + return results + + except HTTPException: + raise + except Exception as e: + logger.exception(f"批量上传表情包失败: {e}") + raise HTTPException(status_code=500, detail=f"批量上传失败: {str(e)}") from e + + +# ==================== 缩略图缓存管理 API ==================== + + +class ThumbnailCacheStatsResponse(BaseModel): + """缩略图缓存统计响应""" + + success: bool + cache_dir: str + total_count: int + total_size_mb: float + emoji_count: int + coverage_percent: float + + +class ThumbnailCleanupResponse(BaseModel): + """缩略图清理响应""" + + success: bool + message: str + cleaned_count: int + kept_count: int + + +class ThumbnailPreheatResponse(BaseModel): + """缩略图预热响应""" + + success: bool + message: str + generated_count: int + skipped_count: int + failed_count: int + + +@router.get("/thumbnail-cache/stats", response_model=ThumbnailCacheStatsResponse) +async def get_thumbnail_cache_stats( + maibot_session: Optional[str] = Cookie(None), + authorization: Optional[str] = Header(None), +): + """ + 获取缩略图缓存统计信息 + + Returns: + 缓存目录、缓存数量、总大小、覆盖率等统计信息 + """ + try: + verify_auth_token(maibot_session, authorization) + + _ensure_thumbnail_cache_dir() + + # 统计缓存文件 + cache_files = list(THUMBNAIL_CACHE_DIR.glob("*.webp")) + total_count = len(cache_files) + total_size = sum(f.stat().st_size for f in cache_files) + total_size_mb = round(total_size / (1024 * 1024), 2) + + # 统计表情包总数 + emoji_count = Emoji.select().count() + + # 计算覆盖率 + coverage_percent = round((total_count / emoji_count * 100) if emoji_count > 0 else 0, 1) + + return ThumbnailCacheStatsResponse( + success=True, + cache_dir=str(THUMBNAIL_CACHE_DIR.absolute()), + total_count=total_count, + total_size_mb=total_size_mb, + emoji_count=emoji_count, + coverage_percent=coverage_percent, + ) + + except HTTPException: + raise + except Exception as e: + logger.exception(f"获取缩略图缓存统计失败: {e}") + raise HTTPException(status_code=500, detail=f"获取统计失败: {str(e)}") from e + + +@router.post("/thumbnail-cache/cleanup", response_model=ThumbnailCleanupResponse) +async def cleanup_thumbnail_cache( + maibot_session: Optional[str] = Cookie(None), + authorization: Optional[str] = Header(None), +): + """ + 清理孤立的缩略图缓存（原图已删除的表情包对应的缩略图） + + Returns: + 清理结果 + """ + try: + verify_auth_token(maibot_session, authorization) + + cleaned, kept = cleanup_orphaned_thumbnails() + + return ThumbnailCleanupResponse( + success=True, + message=f"清理完成：删除 {cleaned} 个孤立缓存，保留 {kept} 个有效缓存", + cleaned_count=cleaned, + kept_count=kept, + ) + + except HTTPException: + raise + except Exception as e: + logger.exception(f"清理缩略图缓存失败: {e}") + raise HTTPException(status_code=500, detail=f"清理失败: {str(e)}") from e + + +@router.post("/thumbnail-cache/preheat", response_model=ThumbnailPreheatResponse) +async def preheat_thumbnail_cache( + limit: int = Query(100, ge=1, le=1000, description="最多预热数量"), + maibot_session: Optional[str] = Cookie(None), + authorization: Optional[str] = Header(None), +): + """ + 预热缩略图缓存（提前生成未缓存的缩略图） + + 优先处理使用次数高的表情包 + + Args: + limit: 最多预热数量 (1-1000) + + Returns: + 预热结果 + """ + try: + verify_auth_token(maibot_session, authorization) + + _ensure_thumbnail_cache_dir() + + # 获取使用次数最高的表情包（未缓存的优先） + emojis = ( + Emoji.select() + .where(Emoji.is_banned == False) # noqa: E712 Peewee ORM requires == for boolean comparison + .order_by(Emoji.usage_count.desc()) + .limit(limit * 2) # 多查一些，因为有些可能已缓存 + ) + + generated = 0 + skipped = 0 + failed = 0 + + for emoji in emojis: + if generated >= limit: + break + + cache_path = _get_thumbnail_cache_path(emoji.emoji_hash) + + # 已缓存，跳过 + if cache_path.exists(): + skipped += 1 + continue + + # 原文件不存在，跳过 + if not os.path.exists(emoji.full_path): + failed += 1 + continue + + try: + # 使用线程池异步生成缩略图，避免阻塞事件循环 + loop = asyncio.get_event_loop() + await loop.run_in_executor(_thumbnail_executor, _generate_thumbnail, emoji.full_path, emoji.emoji_hash) + generated += 1 + except Exception as e: + logger.warning(f"预热缩略图失败 {emoji.emoji_hash}: {e}") + failed += 1 + + return ThumbnailPreheatResponse( + success=True, + message=f"预热完成：生成 {generated} 个，跳过 {skipped} 个已缓存，失败 {failed} 个", + generated_count=generated, + skipped_count=skipped, + failed_count=failed, + ) + + except HTTPException: + raise + except Exception as e: + logger.exception(f"预热缩略图缓存失败: {e}") + raise HTTPException(status_code=500, detail=f"预热失败: {str(e)}") from e + + +@router.delete("/thumbnail-cache/clear", response_model=ThumbnailCleanupResponse) +async def clear_all_thumbnail_cache( + maibot_session: Optional[str] = Cookie(None), + authorization: Optional[str] = Header(None), +): + """ + 清空所有缩略图缓存（下次访问时会重新生成） + + Returns: + 清理结果 + """ + try: + verify_auth_token(maibot_session, authorization) + + if not THUMBNAIL_CACHE_DIR.exists(): + return ThumbnailCleanupResponse( + success=True, + message="缓存目录不存在，无需清理", + cleaned_count=0, + kept_count=0, + ) + + cleaned = 0 + for cache_file in THUMBNAIL_CACHE_DIR.glob("*.webp"): + try: + cache_file.unlink() + cleaned += 1 + except Exception as e: + logger.warning(f"删除缓存文件失败 {cache_file.name}: {e}") + + logger.info(f"已清空缩略图缓存: 删除 {cleaned} 个文件") + + return ThumbnailCleanupResponse( + success=True, + message=f"已清空所有缩略图缓存：删除 {cleaned} 个文件", + cleaned_count=cleaned, + kept_count=0, + ) + + except HTTPException: + raise + except Exception as e: + logger.exception(f"清空缩略图缓存失败: {e}") + raise HTTPException(status_code=500, detail=f"清空失败: {str(e)}") from e diff --git a/src/webui/expression_routes.py b/src/webui/expression_routes.py index 983918cf..b6ec76b3 100644 --- a/src/webui/expression_routes.py +++ b/src/webui/expression_routes.py @@ -1,11 +1,11 @@ """表达方式管理 API 路由""" -from fastapi import APIRouter, HTTPException, Header, Query -from pydantic import BaseModel -from typing import Optional, List +from fastapi import APIRouter, HTTPException, Header, Query, Cookie +from pydantic import BaseModel, NonNegativeFloat +from typing import Optional, List, Dict from src.common.logger import get_logger -from src.common.database.database_model import Expression -from .token_manager import get_token_manager +from src.common.database.database_model import Expression, ChatStreams +from .auth import verify_auth_token_from_cookie_or_header import time logger = get_logger("webui.expression") @@ -21,7 +21,6 @@ class ExpressionResponse(BaseModel): situation: str style: str context: Optional[str] - up_content: Optional[str] last_active_time: float chat_id: str create_date: Optional[float] @@ -49,8 +48,7 @@ class ExpressionCreateRequest(BaseModel): situation: str style: str - context: Optional[str] = None - up_content: Optional[str] = None + context: Optional[str] = NonNegativeFloat chat_id: str @@ -60,7 +58,6 @@ class ExpressionUpdateRequest(BaseModel): situation: Optional[str] = None style: Optional[str] = None context: Optional[str] = None - up_content: Optional[str] = None chat_id: Optional[str] = None @@ -87,18 +84,12 @@ class ExpressionCreateResponse(BaseModel): data: ExpressionResponse -def verify_auth_token(authorization: Optional[str]) -> bool: - """验证认证 Token""" - if not authorization or not authorization.startswith("Bearer "): - raise HTTPException(status_code=401, detail="未提供有效的认证信息") - - token = authorization.replace("Bearer ", "") - token_manager = get_token_manager() - - if not token_manager.verify_token(token): - raise HTTPException(status_code=401, detail="Token 无效或已过期") - - return True +def verify_auth_token( + maibot_session: Optional[str] = None, + authorization: Optional[str] = None, +) -> bool: + """验证认证 Token，支持 Cookie 和 Header""" + return verify_auth_token_from_cookie_or_header(maibot_session, authorization) def expression_to_response(expression: Expression) -> ExpressionResponse: @@ -108,19 +99,103 @@ def expression_to_response(expression: Expression) -> ExpressionResponse: situation=expression.situation, style=expression.style, context=expression.context, - up_content=expression.up_content, last_active_time=expression.last_active_time, chat_id=expression.chat_id, create_date=expression.create_date, ) +def get_chat_name(chat_id: str) -> str: + """根据 chat_id 获取聊天名称""" + try: + chat_stream = ChatStreams.get_or_none(ChatStreams.stream_id == chat_id) + if chat_stream: + # 优先使用群聊名称，否则使用用户昵称 + if chat_stream.group_name: + return chat_stream.group_name + elif chat_stream.user_nickname: + return chat_stream.user_nickname + return chat_id # 找不到时返回原始ID + except Exception: + return chat_id + + +def get_chat_names_batch(chat_ids: List[str]) -> Dict[str, str]: + """批量获取聊天名称""" + result = {cid: cid for cid in chat_ids} # 默认值为原始ID + try: + chat_streams = ChatStreams.select().where(ChatStreams.stream_id.in_(chat_ids)) + for cs in chat_streams: + if cs.group_name: + result[cs.stream_id] = cs.group_name + elif cs.user_nickname: + result[cs.stream_id] = cs.user_nickname + except Exception as e: + logger.warning(f"批量获取聊天名称失败: {e}") + return result + + +class ChatInfo(BaseModel): + """聊天信息""" + + chat_id: str + chat_name: str + platform: Optional[str] = None + is_group: bool = False + + +class ChatListResponse(BaseModel): + """聊天列表响应""" + + success: bool + data: List[ChatInfo] + + +@router.get("/chats", response_model=ChatListResponse) +async def get_chat_list(maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None)): + """ + 获取所有聊天列表（用于下拉选择） + + Args: + authorization: Authorization header + + Returns: + 聊天列表 + """ + try: + verify_auth_token(maibot_session, authorization) + + chat_list = [] + for cs in ChatStreams.select(): + chat_name = cs.group_name if cs.group_name else (cs.user_nickname if cs.user_nickname else cs.stream_id) + chat_list.append( + ChatInfo( + chat_id=cs.stream_id, + chat_name=chat_name, + platform=cs.platform, + is_group=bool(cs.group_id), + ) + ) + + # 按名称排序 + chat_list.sort(key=lambda x: x.chat_name) + + return ChatListResponse(success=True, data=chat_list) + + except HTTPException: + raise + except Exception as e: + logger.exception(f"获取聊天列表失败: {e}") + raise HTTPException(status_code=500, detail=f"获取聊天列表失败: {str(e)}") from e + + @router.get("/list", response_model=ExpressionListResponse) async def get_expression_list( page: int = Query(1, ge=1, description="页码"), page_size: int = Query(20, ge=1, le=100, description="每页数量"), search: Optional[str] = Query(None, description="搜索关键词"), chat_id: Optional[str] = Query(None, description="聊天ID筛选"), + maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None), ): """ @@ -137,7 +212,7 @@ async def get_expression_list( 表达方式列表 """ try: - verify_auth_token(authorization) + verify_auth_token(maibot_session, authorization) # 构建查询 query = Expression.select() @@ -181,7 +256,9 @@ async def get_expression_list( @router.get("/{expression_id}", response_model=ExpressionDetailResponse) -async def get_expression_detail(expression_id: int, authorization: Optional[str] = Header(None)): +async def get_expression_detail( + expression_id: int, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None) +): """ 获取表达方式详细信息 @@ -193,7 +270,7 @@ async def get_expression_detail(expression_id: int, authorization: Optional[str] 表达方式详细信息 """ try: - verify_auth_token(authorization) + verify_auth_token(maibot_session, authorization) expression = Expression.get_or_none(Expression.id == expression_id) @@ -210,7 +287,11 @@ async def get_expression_detail(expression_id: int, authorization: Optional[str] @router.post("/", response_model=ExpressionCreateResponse) -async def create_expression(request: ExpressionCreateRequest, authorization: Optional[str] = Header(None)): +async def create_expression( + request: ExpressionCreateRequest, + maibot_session: Optional[str] = Cookie(None), + authorization: Optional[str] = Header(None), +): """ 创建新的表达方式 @@ -222,7 +303,7 @@ async def create_expression(request: ExpressionCreateRequest, authorization: Opt 创建结果 """ try: - verify_auth_token(authorization) + verify_auth_token(maibot_session, authorization) current_time = time.time() @@ -231,7 +312,6 @@ async def create_expression(request: ExpressionCreateRequest, authorization: Opt situation=request.situation, style=request.style, context=request.context, - up_content=request.up_content, chat_id=request.chat_id, last_active_time=current_time, create_date=current_time, @@ -252,7 +332,10 @@ async def create_expression(request: ExpressionCreateRequest, authorization: Opt @router.patch("/{expression_id}", response_model=ExpressionUpdateResponse) async def update_expression( - expression_id: int, request: ExpressionUpdateRequest, authorization: Optional[str] = Header(None) + expression_id: int, + request: ExpressionUpdateRequest, + maibot_session: Optional[str] = Cookie(None), + authorization: Optional[str] = Header(None), ): """ 增量更新表达方式（只更新提供的字段） @@ -266,7 +349,7 @@ async def update_expression( 更新结果 """ try: - verify_auth_token(authorization) + verify_auth_token(maibot_session, authorization) expression = Expression.get_or_none(Expression.id == expression_id) @@ -302,7 +385,9 @@ async def update_expression( @router.delete("/{expression_id}", response_model=ExpressionDeleteResponse) -async def delete_expression(expression_id: int, authorization: Optional[str] = Header(None)): +async def delete_expression( + expression_id: int, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None) +): """ 删除表达方式 @@ -314,7 +399,7 @@ async def delete_expression(expression_id: int, authorization: Optional[str] = H 删除结果 """ try: - verify_auth_token(authorization) + verify_auth_token(maibot_session, authorization) expression = Expression.get_or_none(Expression.id == expression_id) @@ -345,7 +430,11 @@ class BatchDeleteRequest(BaseModel): @router.post("/batch/delete", response_model=ExpressionDeleteResponse) -async def batch_delete_expressions(request: BatchDeleteRequest, authorization: Optional[str] = Header(None)): +async def batch_delete_expressions( + request: BatchDeleteRequest, + maibot_session: Optional[str] = Cookie(None), + authorization: Optional[str] = Header(None), +): """ 批量删除表达方式 @@ -357,7 +446,7 @@ async def batch_delete_expressions(request: BatchDeleteRequest, authorization: O 删除结果 """ try: - verify_auth_token(authorization) + verify_auth_token(maibot_session, authorization) if not request.ids: raise HTTPException(status_code=400, detail="未提供要删除的表达方式ID") @@ -386,7 +475,9 @@ async def batch_delete_expressions(request: BatchDeleteRequest, authorization: O @router.get("/stats/summary") -async def get_expression_stats(authorization: Optional[str] = Header(None)): +async def get_expression_stats( + maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None) +): """ 获取表达方式统计数据 @@ -397,7 +488,7 @@ async def get_expression_stats(authorization: Optional[str] = Header(None)): 统计数据 """ try: - verify_auth_token(authorization) + verify_auth_token(maibot_session, authorization) total = Expression.select().count() diff --git a/src/webui/git_mirror_service.py b/src/webui/git_mirror_service.py index df00cde9..a6a9b1bc 100644 --- a/src/webui/git_mirror_service.py +++ b/src/webui/git_mirror_service.py @@ -602,9 +602,9 @@ class GitMirrorService: # 执行 git clone（在线程池中运行以避免阻塞） loop = asyncio.get_event_loop() - def run_git_clone(): + def run_git_clone(clone_cmd=cmd): return subprocess.run( - cmd, + clone_cmd, capture_output=True, text=True, timeout=300, # 5分钟超时 diff --git a/src/webui/jargon_routes.py b/src/webui/jargon_routes.py new file mode 100644 index 00000000..8d372688 --- /dev/null +++ b/src/webui/jargon_routes.py @@ -0,0 +1,532 @@ +"""黑话（俚语）管理路由""" + +import json +from typing import Optional, List, Annotated +from fastapi import APIRouter, HTTPException, Query +from pydantic import BaseModel, Field +from peewee import fn + +from src.common.logger import get_logger +from src.common.database.database_model import Jargon, ChatStreams + +logger = get_logger("webui.jargon") + +router = APIRouter(prefix="/jargon", tags=["Jargon"]) + + +# ==================== 辅助函数 ==================== + + +def parse_chat_id_to_stream_ids(chat_id_str: str) -> List[str]: + """ + 解析 chat_id 字段，提取所有 stream_id + chat_id 格式: [["stream_id", user_id], ...] 或直接是 stream_id 字符串 + """ + if not chat_id_str: + return [] + + try: + # 尝试解析为 JSON + parsed = json.loads(chat_id_str) + if isinstance(parsed, list): + # 格式: [["stream_id", user_id], ...] + stream_ids = [] + for item in parsed: + if isinstance(item, list) and len(item) >= 1: + stream_ids.append(str(item[0])) + return stream_ids + else: + # 其他格式，返回原始字符串 + return [chat_id_str] + except (json.JSONDecodeError, TypeError): + # 不是有效的 JSON，可能是直接的 stream_id + return [chat_id_str] + + +def get_display_name_for_chat_id(chat_id_str: str) -> str: + """ + 获取 chat_id 的显示名称 + 尝试解析 JSON 并查询 ChatStreams 表获取群聊名称 + """ + stream_ids = parse_chat_id_to_stream_ids(chat_id_str) + + if not stream_ids: + return chat_id_str + + # 查询所有 stream_id 对应的名称 + names = [] + for stream_id in stream_ids: + chat_stream = ChatStreams.get_or_none(ChatStreams.stream_id == stream_id) + if chat_stream and chat_stream.group_name: + names.append(chat_stream.group_name) + else: + # 如果没找到，显示截断的 stream_id + names.append(stream_id[:8] + "..." if len(stream_id) > 8 else stream_id) + + return ", ".join(names) if names else chat_id_str + + +# ==================== 请求/响应模型 ==================== + + +class JargonResponse(BaseModel): + """黑话信息响应""" + + id: int + content: str + raw_content: Optional[str] = None + meaning: Optional[str] = None + chat_id: str + stream_id: Optional[str] = None # 解析后的 stream_id，用于前端编辑时匹配 + chat_name: Optional[str] = None # 解析后的聊天名称，用于前端显示 + is_global: bool = False + count: int = 0 + is_jargon: Optional[bool] = None + is_complete: bool = False + inference_with_context: Optional[str] = None + inference_content_only: Optional[str] = None + + +class JargonListResponse(BaseModel): + """黑话列表响应""" + + success: bool = True + total: int + page: int + page_size: int + data: List[JargonResponse] + + +class JargonDetailResponse(BaseModel): + """黑话详情响应""" + + success: bool = True + data: JargonResponse + + +class JargonCreateRequest(BaseModel): + """黑话创建请求""" + + content: str = Field(..., description="黑话内容") + raw_content: Optional[str] = Field(None, description="原始内容") + meaning: Optional[str] = Field(None, description="含义") + chat_id: str = Field(..., description="聊天ID") + is_global: bool = Field(False, description="是否全局") + + +class JargonUpdateRequest(BaseModel): + """黑话更新请求""" + + content: Optional[str] = None + raw_content: Optional[str] = None + meaning: Optional[str] = None + chat_id: Optional[str] = None + is_global: Optional[bool] = None + is_jargon: Optional[bool] = None + + +class JargonCreateResponse(BaseModel): + """黑话创建响应""" + + success: bool = True + message: str + data: JargonResponse + + +class JargonUpdateResponse(BaseModel): + """黑话更新响应""" + + success: bool = True + message: str + data: Optional[JargonResponse] = None + + +class JargonDeleteResponse(BaseModel): + """黑话删除响应""" + + success: bool = True + message: str + deleted_count: int = 0 + + +class BatchDeleteRequest(BaseModel): + """批量删除请求""" + + ids: List[int] = Field(..., description="要删除的黑话ID列表") + + +class JargonStatsResponse(BaseModel): + """黑话统计响应""" + + success: bool = True + data: dict + + +class ChatInfoResponse(BaseModel): + """聊天信息响应""" + + chat_id: str + chat_name: str + platform: Optional[str] = None + is_group: bool = False + + +class ChatListResponse(BaseModel): + """聊天列表响应""" + + success: bool = True + data: List[ChatInfoResponse] + + +# ==================== 工具函数 ==================== + + +def jargon_to_dict(jargon: Jargon) -> dict: + """将 Jargon ORM 对象转换为字典""" + # 解析 chat_id 获取显示名称和 stream_id + chat_name = get_display_name_for_chat_id(jargon.chat_id) if jargon.chat_id else None + stream_ids = parse_chat_id_to_stream_ids(jargon.chat_id) if jargon.chat_id else [] + stream_id = stream_ids[0] if stream_ids else None + + return { + "id": jargon.id, + "content": jargon.content, + "raw_content": jargon.raw_content, + "meaning": jargon.meaning, + "chat_id": jargon.chat_id, + "stream_id": stream_id, + "chat_name": chat_name, + "is_global": jargon.is_global, + "count": jargon.count, + "is_jargon": jargon.is_jargon, + "is_complete": jargon.is_complete, + "inference_with_context": jargon.inference_with_context, + "inference_content_only": jargon.inference_content_only, + } + + +# ==================== API 端点 ==================== + + +@router.get("/list", response_model=JargonListResponse) +async def get_jargon_list( + page: int = Query(1, ge=1, description="页码"), + page_size: int = Query(20, ge=1, le=100, description="每页数量"), + search: Optional[str] = Query(None, description="搜索关键词"), + chat_id: Optional[str] = Query(None, description="按聊天ID筛选"), + is_jargon: Optional[bool] = Query(None, description="按是否是黑话筛选"), + is_global: Optional[bool] = Query(None, description="按是否全局筛选"), +): + """获取黑话列表""" + try: + # 构建查询 + query = Jargon.select() + + # 搜索过滤 + if search: + query = query.where( + (Jargon.content.contains(search)) + | (Jargon.meaning.contains(search)) + | (Jargon.raw_content.contains(search)) + ) + + # 按聊天ID筛选（使用 contains 匹配，因为 chat_id 是 JSON 格式） + if chat_id: + # 从传入的 chat_id 中解析出 stream_id + stream_ids = parse_chat_id_to_stream_ids(chat_id) + if stream_ids: + # 使用第一个 stream_id 进行模糊匹配 + query = query.where(Jargon.chat_id.contains(stream_ids[0])) + else: + # 如果无法解析，使用精确匹配 + query = query.where(Jargon.chat_id == chat_id) + + # 按是否是黑话筛选 + if is_jargon is not None: + query = query.where(Jargon.is_jargon == is_jargon) + + # 按是否全局筛选 + if is_global is not None: + query = query.where(Jargon.is_global == is_global) + + # 获取总数 + total = query.count() + + # 分页和排序（按使用次数降序） + query = query.order_by(Jargon.count.desc(), Jargon.id.desc()) + query = query.paginate(page, page_size) + + # 转换为响应格式 + data = [jargon_to_dict(j) for j in query] + + return JargonListResponse( + success=True, + total=total, + page=page, + page_size=page_size, + data=data, + ) + + except Exception as e: + logger.error(f"获取黑话列表失败: {e}") + raise HTTPException(status_code=500, detail=f"获取黑话列表失败: {str(e)}") from e + + +@router.get("/chats", response_model=ChatListResponse) +async def get_chat_list(): + """获取所有有黑话记录的聊天列表""" + try: + # 获取所有不同的 chat_id + chat_ids = Jargon.select(Jargon.chat_id).distinct().where(Jargon.chat_id.is_null(False)) + + chat_id_list = [j.chat_id for j in chat_ids if j.chat_id] + + # 用于按 stream_id 去重 + seen_stream_ids: set[str] = set() + + for chat_id in chat_id_list: + stream_ids = parse_chat_id_to_stream_ids(chat_id) + if stream_ids: + seen_stream_ids.add(stream_ids[0]) + + result = [] + for stream_id in seen_stream_ids: + # 尝试从 ChatStreams 表获取聊天名称 + chat_stream = ChatStreams.get_or_none(ChatStreams.stream_id == stream_id) + if chat_stream: + result.append( + ChatInfoResponse( + chat_id=stream_id, # 使用 stream_id，方便筛选匹配 + chat_name=chat_stream.group_name or stream_id, + platform=chat_stream.platform, + is_group=True, + ) + ) + else: + result.append( + ChatInfoResponse( + chat_id=stream_id, # 使用 stream_id + chat_name=stream_id[:8] + "..." if len(stream_id) > 8 else stream_id, + platform=None, + is_group=False, + ) + ) + + return ChatListResponse(success=True, data=result) + + except Exception as e: + logger.error(f"获取聊天列表失败: {e}") + raise HTTPException(status_code=500, detail=f"获取聊天列表失败: {str(e)}") from e + + +@router.get("/stats/summary", response_model=JargonStatsResponse) +async def get_jargon_stats(): + """获取黑话统计数据""" + try: + # 总数量 + total = Jargon.select().count() + + # 已确认是黑话的数量 + confirmed_jargon = Jargon.select().where(Jargon.is_jargon).count() + + # 已确认不是黑话的数量 + confirmed_not_jargon = Jargon.select().where(~Jargon.is_jargon).count() + + # 未判定的数量 + pending = Jargon.select().where(Jargon.is_jargon.is_null()).count() + + # 全局黑话数量 + global_count = Jargon.select().where(Jargon.is_global).count() + + # 已完成推断的数量 + complete_count = Jargon.select().where(Jargon.is_complete).count() + + # 关联的聊天数量 + chat_count = Jargon.select(Jargon.chat_id).distinct().where(Jargon.chat_id.is_null(False)).count() + + # 按聊天统计 TOP 5 + top_chats = ( + Jargon.select(Jargon.chat_id, fn.COUNT(Jargon.id).alias("count")) + .group_by(Jargon.chat_id) + .order_by(fn.COUNT(Jargon.id).desc()) + .limit(5) + ) + top_chats_dict = {j.chat_id: j.count for j in top_chats if j.chat_id} + + return JargonStatsResponse( + success=True, + data={ + "total": total, + "confirmed_jargon": confirmed_jargon, + "confirmed_not_jargon": confirmed_not_jargon, + "pending": pending, + "global_count": global_count, + "complete_count": complete_count, + "chat_count": chat_count, + "top_chats": top_chats_dict, + }, + ) + + except Exception as e: + logger.error(f"获取黑话统计失败: {e}") + raise HTTPException(status_code=500, detail=f"获取黑话统计失败: {str(e)}") from e + + +@router.get("/{jargon_id}", response_model=JargonDetailResponse) +async def get_jargon_detail(jargon_id: int): + """获取黑话详情""" + try: + jargon = Jargon.get_or_none(Jargon.id == jargon_id) + if not jargon: + raise HTTPException(status_code=404, detail="黑话不存在") + + return JargonDetailResponse(success=True, data=jargon_to_dict(jargon)) + + except HTTPException: + raise + except Exception as e: + logger.error(f"获取黑话详情失败: {e}") + raise HTTPException(status_code=500, detail=f"获取黑话详情失败: {str(e)}") from e + + +@router.post("/", response_model=JargonCreateResponse) +async def create_jargon(request: JargonCreateRequest): + """创建黑话""" + try: + # 检查是否已存在相同内容的黑话 + existing = Jargon.get_or_none((Jargon.content == request.content) & (Jargon.chat_id == request.chat_id)) + if existing: + raise HTTPException(status_code=400, detail="该聊天中已存在相同内容的黑话") + + # 创建黑话 + jargon = Jargon.create( + content=request.content, + raw_content=request.raw_content, + meaning=request.meaning, + chat_id=request.chat_id, + is_global=request.is_global, + count=0, + is_jargon=None, + is_complete=False, + ) + + logger.info(f"创建黑话成功: id={jargon.id}, content={request.content}") + + return JargonCreateResponse( + success=True, + message="创建成功", + data=jargon_to_dict(jargon), + ) + + except HTTPException: + raise + except Exception as e: + logger.error(f"创建黑话失败: {e}") + raise HTTPException(status_code=500, detail=f"创建黑话失败: {str(e)}") from e + + +@router.patch("/{jargon_id}", response_model=JargonUpdateResponse) +async def update_jargon(jargon_id: int, request: JargonUpdateRequest): + """更新黑话（增量更新）""" + try: + jargon = Jargon.get_or_none(Jargon.id == jargon_id) + if not jargon: + raise HTTPException(status_code=404, detail="黑话不存在") + + # 增量更新字段 + update_data = request.model_dump(exclude_unset=True) + if update_data: + for field, value in update_data.items(): + if value is not None or field in ["meaning", "raw_content", "is_jargon"]: + setattr(jargon, field, value) + jargon.save() + + logger.info(f"更新黑话成功: id={jargon_id}") + + return JargonUpdateResponse( + success=True, + message="更新成功", + data=jargon_to_dict(jargon), + ) + + except HTTPException: + raise + except Exception as e: + logger.error(f"更新黑话失败: {e}") + raise HTTPException(status_code=500, detail=f"更新黑话失败: {str(e)}") from e + + +@router.delete("/{jargon_id}", response_model=JargonDeleteResponse) +async def delete_jargon(jargon_id: int): + """删除黑话""" + try: + jargon = Jargon.get_or_none(Jargon.id == jargon_id) + if not jargon: + raise HTTPException(status_code=404, detail="黑话不存在") + + content = jargon.content + jargon.delete_instance() + + logger.info(f"删除黑话成功: id={jargon_id}, content={content}") + + return JargonDeleteResponse( + success=True, + message="删除成功", + deleted_count=1, + ) + + except HTTPException: + raise + except Exception as e: + logger.error(f"删除黑话失败: {e}") + raise HTTPException(status_code=500, detail=f"删除黑话失败: {str(e)}") from e + + +@router.post("/batch/delete", response_model=JargonDeleteResponse) +async def batch_delete_jargons(request: BatchDeleteRequest): + """批量删除黑话""" + try: + if not request.ids: + raise HTTPException(status_code=400, detail="ID列表不能为空") + + deleted_count = Jargon.delete().where(Jargon.id.in_(request.ids)).execute() + + logger.info(f"批量删除黑话成功: 删除了 {deleted_count} 条记录") + + return JargonDeleteResponse( + success=True, + message=f"成功删除 {deleted_count} 条黑话", + deleted_count=deleted_count, + ) + + except HTTPException: + raise + except Exception as e: + logger.error(f"批量删除黑话失败: {e}") + raise HTTPException(status_code=500, detail=f"批量删除黑话失败: {str(e)}") from e + + +@router.post("/batch/set-jargon", response_model=JargonUpdateResponse) +async def batch_set_jargon_status( + ids: Annotated[List[int], Query(description="黑话ID列表")], + is_jargon: Annotated[bool, Query(description="是否是黑话")], +): + """批量设置黑话状态""" + try: + if not ids: + raise HTTPException(status_code=400, detail="ID列表不能为空") + + updated_count = Jargon.update(is_jargon=is_jargon).where(Jargon.id.in_(ids)).execute() + + logger.info(f"批量更新黑话状态成功: 更新了 {updated_count} 条记录，is_jargon={is_jargon}") + + return JargonUpdateResponse( + success=True, + message=f"成功更新 {updated_count} 条黑话状态", + ) + + except HTTPException: + raise + except Exception as e: + logger.error(f"批量更新黑话状态失败: {e}") + raise HTTPException(status_code=500, detail=f"批量更新黑话状态失败: {str(e)}") from e diff --git a/src/webui/knowledge_routes.py b/src/webui/knowledge_routes.py new file mode 100644 index 00000000..87b2e7b5 --- /dev/null +++ b/src/webui/knowledge_routes.py @@ -0,0 +1,298 @@ +"""知识库图谱可视化 API 路由""" + +from typing import List, Optional +from fastapi import APIRouter, Query, Depends, Cookie, Header +from pydantic import BaseModel +import logging +from src.webui.auth import verify_auth_token_from_cookie_or_header + +logger = logging.getLogger(__name__) + +router = APIRouter(prefix="/api/webui/knowledge", tags=["knowledge"]) + + +def require_auth( + maibot_session: Optional[str] = Cookie(None), + authorization: Optional[str] = Header(None), +) -> bool: + """认证依赖：验证用户是否已登录""" + return verify_auth_token_from_cookie_or_header(maibot_session, authorization) + + +class KnowledgeNode(BaseModel): + """知识节点""" + + id: str + type: str # 'entity' or 'paragraph' + content: str + create_time: Optional[float] = None + + +class KnowledgeEdge(BaseModel): + """知识边""" + + source: str + target: str + weight: float + create_time: Optional[float] = None + update_time: Optional[float] = None + + +class KnowledgeGraph(BaseModel): + """知识图谱""" + + nodes: List[KnowledgeNode] + edges: List[KnowledgeEdge] + + +class KnowledgeStats(BaseModel): + """知识库统计信息""" + + total_nodes: int + total_edges: int + entity_nodes: int + paragraph_nodes: int + avg_connections: float + + +def _load_kg_manager(): + """延迟加载 KGManager""" + try: + from src.chat.knowledge.kg_manager import KGManager + + kg_manager = KGManager() + kg_manager.load_from_file() + return kg_manager + except Exception as e: + logger.error(f"加载 KGManager 失败: {e}") + return None + + +def _convert_graph_to_json(kg_manager) -> KnowledgeGraph: + """将 DiGraph 转换为 JSON 格式""" + if kg_manager is None or kg_manager.graph is None: + return KnowledgeGraph(nodes=[], edges=[]) + + graph = kg_manager.graph + nodes = [] + edges = [] + + # 转换节点 + node_list = graph.get_node_list() + for node_id in node_list: + try: + node_data = graph[node_id] + # 节点类型: "ent" -> "entity", "pg" -> "paragraph" + node_type = "entity" if ("type" in node_data and node_data["type"] == "ent") else "paragraph" + content = node_data["content"] if "content" in node_data else node_id + create_time = node_data["create_time"] if "create_time" in node_data else None + + nodes.append(KnowledgeNode(id=node_id, type=node_type, content=content, create_time=create_time)) + except Exception as e: + logger.warning(f"跳过节点 {node_id}: {e}") + continue + + # 转换边 + edge_list = graph.get_edge_list() + for edge_tuple in edge_list: + try: + # edge_tuple 是 (source, target) 元组 + source, target = edge_tuple[0], edge_tuple[1] + # 通过 graph[source, target] 获取边的属性数据 + edge_data = graph[source, target] + + # edge_data 支持 [] 操作符但不支持 .get() + weight = edge_data["weight"] if "weight" in edge_data else 1.0 + create_time = edge_data["create_time"] if "create_time" in edge_data else None + update_time = edge_data["update_time"] if "update_time" in edge_data else None + + edges.append( + KnowledgeEdge( + source=source, target=target, weight=weight, create_time=create_time, update_time=update_time + ) + ) + except Exception as e: + logger.warning(f"跳过边 {edge_tuple}: {e}") + continue + + return KnowledgeGraph(nodes=nodes, edges=edges) + + +@router.get("/graph", response_model=KnowledgeGraph) +async def get_knowledge_graph( + limit: int = Query(100, ge=1, le=10000, description="返回的最大节点数"), + node_type: str = Query("all", description="节点类型过滤: all, entity, paragraph"), + _auth: bool = Depends(require_auth), +): + """获取知识图谱(限制节点数量) + + Args: + limit: 返回的最大节点数,默认 100,最大 10000 + node_type: 节点类型过滤 - all(全部), entity(实体), paragraph(段落) + + Returns: + KnowledgeGraph: 包含指定数量节点和相关边的知识图谱 + """ + try: + kg_manager = _load_kg_manager() + if kg_manager is None: + logger.warning("KGManager 未初始化，返回空图谱") + return KnowledgeGraph(nodes=[], edges=[]) + + graph = kg_manager.graph + all_node_list = graph.get_node_list() + + # 按类型过滤节点 + if node_type == "entity": + all_node_list = [ + n for n in all_node_list if n in graph and "type" in graph[n] and graph[n]["type"] == "ent" + ] + elif node_type == "paragraph": + all_node_list = [n for n in all_node_list if n in graph and "type" in graph[n] and graph[n]["type"] == "pg"] + + # 限制节点数量 + total_nodes = len(all_node_list) + if len(all_node_list) > limit: + node_list = all_node_list[:limit] + else: + node_list = all_node_list + + logger.info(f"总节点数: {total_nodes}, 返回节点: {len(node_list)} (limit={limit}, type={node_type})") + + # 转换节点 + nodes = [] + node_ids = set() + for node_id in node_list: + try: + node_data = graph[node_id] + node_type_val = "entity" if ("type" in node_data and node_data["type"] == "ent") else "paragraph" + content = node_data["content"] if "content" in node_data else node_id + create_time = node_data["create_time"] if "create_time" in node_data else None + + nodes.append(KnowledgeNode(id=node_id, type=node_type_val, content=content, create_time=create_time)) + node_ids.add(node_id) + except Exception as e: + logger.warning(f"跳过节点 {node_id}: {e}") + continue + + # 只获取涉及当前节点集的边(保证图的完整性) + edges = [] + edge_list = graph.get_edge_list() + for edge_tuple in edge_list: + try: + source, target = edge_tuple[0], edge_tuple[1] + # 只包含两端都在当前节点集中的边 + if source not in node_ids or target not in node_ids: + continue + + edge_data = graph[source, target] + weight = edge_data["weight"] if "weight" in edge_data else 1.0 + create_time = edge_data["create_time"] if "create_time" in edge_data else None + update_time = edge_data["update_time"] if "update_time" in edge_data else None + + edges.append( + KnowledgeEdge( + source=source, target=target, weight=weight, create_time=create_time, update_time=update_time + ) + ) + except Exception as e: + logger.warning(f"跳过边 {edge_tuple}: {e}") + continue + + graph_data = KnowledgeGraph(nodes=nodes, edges=edges) + logger.info(f"返回知识图谱: {len(nodes)} 个节点, {len(edges)} 条边") + return graph_data + + except Exception as e: + logger.error(f"获取知识图谱失败: {e}", exc_info=True) + return KnowledgeGraph(nodes=[], edges=[]) + + +@router.get("/stats", response_model=KnowledgeStats) +async def get_knowledge_stats(_auth: bool = Depends(require_auth)): + """获取知识库统计信息 + + Returns: + KnowledgeStats: 统计信息 + """ + try: + kg_manager = _load_kg_manager() + if kg_manager is None or kg_manager.graph is None: + return KnowledgeStats(total_nodes=0, total_edges=0, entity_nodes=0, paragraph_nodes=0, avg_connections=0.0) + + graph = kg_manager.graph + node_list = graph.get_node_list() + edge_list = graph.get_edge_list() + + total_nodes = len(node_list) + total_edges = len(edge_list) + + # 统计节点类型 + entity_nodes = 0 + paragraph_nodes = 0 + for node_id in node_list: + try: + node_data = graph[node_id] + node_type = node_data["type"] if "type" in node_data else "ent" + if node_type == "ent": + entity_nodes += 1 + elif node_type == "pg": + paragraph_nodes += 1 + except Exception: + continue + + # 计算平均连接数 + avg_connections = (total_edges * 2) / total_nodes if total_nodes > 0 else 0.0 + + return KnowledgeStats( + total_nodes=total_nodes, + total_edges=total_edges, + entity_nodes=entity_nodes, + paragraph_nodes=paragraph_nodes, + avg_connections=round(avg_connections, 2), + ) + + except Exception as e: + logger.error(f"获取统计信息失败: {e}", exc_info=True) + return KnowledgeStats(total_nodes=0, total_edges=0, entity_nodes=0, paragraph_nodes=0, avg_connections=0.0) + + +@router.get("/search", response_model=List[KnowledgeNode]) +async def search_knowledge_node(query: str = Query(..., min_length=1), _auth: bool = Depends(require_auth)): + """搜索知识节点 + + Args: + query: 搜索关键词 + + Returns: + List[KnowledgeNode]: 匹配的节点列表 + """ + try: + kg_manager = _load_kg_manager() + if kg_manager is None or kg_manager.graph is None: + return [] + + graph = kg_manager.graph + node_list = graph.get_node_list() + results = [] + query_lower = query.lower() + + # 在节点内容中搜索 + for node_id in node_list: + try: + node_data = graph[node_id] + content = node_data["content"] if "content" in node_data else node_id + node_type = "entity" if ("type" in node_data and node_data["type"] == "ent") else "paragraph" + + if query_lower in content.lower() or query_lower in node_id.lower(): + create_time = node_data["create_time"] if "create_time" in node_data else None + results.append(KnowledgeNode(id=node_id, type=node_type, content=content, create_time=create_time)) + except Exception: + continue + + logger.info(f"搜索 '{query}' 找到 {len(results)} 个节点") + return results[:50] # 限制返回数量 + + except Exception as e: + logger.error(f"搜索节点失败: {e}", exc_info=True) + return [] diff --git a/src/webui/logs_ws.py b/src/webui/logs_ws.py index e0e0a9a1..5ae92189 100644 --- a/src/webui/logs_ws.py +++ b/src/webui/logs_ws.py @@ -1,10 +1,12 @@ """WebSocket 日志推送模块""" -from fastapi import APIRouter, WebSocket, WebSocketDisconnect -from typing import Set +from fastapi import APIRouter, WebSocket, WebSocketDisconnect, Query +from typing import Set, Optional import json from pathlib import Path from src.common.logger import get_logger +from src.webui.token_manager import get_token_manager +from src.webui.ws_auth import verify_ws_token logger = get_logger("webui.logs_ws") router = APIRouter() @@ -73,14 +75,48 @@ def load_recent_logs(limit: int = 100) -> list[dict]: @router.websocket("/ws/logs") -async def websocket_logs(websocket: WebSocket): +async def websocket_logs(websocket: WebSocket, token: Optional[str] = Query(None)): """WebSocket 日志推送端点 客户端连接后会持续接收服务器端的日志消息 + 支持三种认证方式（按优先级）： + 1. query 参数 token（推荐，通过 /api/webui/ws-token 获取临时 token） + 2. Cookie 中的 maibot_session + 3. 直接使用 session token（兼容） + + 示例：ws://host/ws/logs?token=xxx """ + is_authenticated = False + + # 方式 1: 尝试验证临时 WebSocket token（推荐方式） + if token and verify_ws_token(token): + is_authenticated = True + logger.debug("WebSocket 使用临时 token 认证成功") + + # 方式 2: 尝试从 Cookie 获取 session token + if not is_authenticated: + cookie_token = websocket.cookies.get("maibot_session") + if cookie_token: + token_manager = get_token_manager() + if token_manager.verify_token(cookie_token): + is_authenticated = True + logger.debug("WebSocket 使用 Cookie 认证成功") + + # 方式 3: 尝试直接验证 query 参数作为 session token（兼容旧方式） + if not is_authenticated and token: + token_manager = get_token_manager() + if token_manager.verify_token(token): + is_authenticated = True + logger.debug("WebSocket 使用 session token 认证成功") + + if not is_authenticated: + logger.warning("WebSocket 连接被拒绝：认证失败") + await websocket.close(code=4001, reason="认证失败，请重新登录") + return + await websocket.accept() active_connections.add(websocket) - logger.info(f"📡 WebSocket 客户端已连接，当前连接数: {len(active_connections)}") + logger.info(f"📡 WebSocket 客户端已连接（已认证），当前连接数: {len(active_connections)}") # 连接建立后，立即发送历史日志 try: diff --git a/src/webui/model_routes.py b/src/webui/model_routes.py new file mode 100644 index 00000000..a84241b9 --- /dev/null +++ b/src/webui/model_routes.py @@ -0,0 +1,383 @@ +""" +模型列表获取API路由 + +提供从各个 AI 厂商 API 获取可用模型列表的代理接口 +""" + +import os +import httpx +from fastapi import APIRouter, HTTPException, Query, Depends, Cookie, Header +from typing import Optional +import tomlkit + +from src.common.logger import get_logger +from src.config.config import CONFIG_DIR +from src.webui.auth import verify_auth_token_from_cookie_or_header + +logger = get_logger("webui") + +router = APIRouter(prefix="/models", tags=["models"]) + + +def require_auth( + maibot_session: Optional[str] = Cookie(None), + authorization: Optional[str] = Header(None), +) -> bool: + """认证依赖：验证用户是否已登录""" + return verify_auth_token_from_cookie_or_header(maibot_session, authorization) + + +# 模型获取器配置 +MODEL_FETCHER_CONFIG = { + # OpenAI 兼容格式的提供商 + "openai": { + "endpoint": "/models", + "parser": "openai", + }, + # Gemini 格式 + "gemini": { + "endpoint": "/models", + "parser": "gemini", + }, +} + + +def _normalize_url(url: str) -> str: + """规范化 URL（去掉尾部斜杠）""" + if not url: + return "" + return url.rstrip("/") + + +def _parse_openai_response(data: dict) -> list[dict]: + """ + 解析 OpenAI 格式的模型列表响应 + + 格式: { "data": [{ "id": "gpt-4", "object": "model", ... }] } + """ + models = [] + if "data" in data and isinstance(data["data"], list): + for model in data["data"]: + if isinstance(model, dict) and "id" in model: + models.append( + { + "id": model["id"], + "name": model.get("name") or model["id"], + "owned_by": model.get("owned_by", ""), + } + ) + return models + + +def _parse_gemini_response(data: dict) -> list[dict]: + """ + 解析 Gemini 格式的模型列表响应 + + 格式: { "models": [{ "name": "models/gemini-pro", "displayName": "Gemini Pro", ... }] } + """ + models = [] + if "models" in data and isinstance(data["models"], list): + for model in data["models"]: + if isinstance(model, dict) and "name" in model: + # Gemini 的 name 格式是 "models/gemini-pro"，我们只取后面部分 + model_id = model["name"] + if model_id.startswith("models/"): + model_id = model_id[7:] # 去掉 "models/" 前缀 + models.append( + { + "id": model_id, + "name": model.get("displayName") or model_id, + "owned_by": "google", + } + ) + return models + + +async def _fetch_models_from_provider( + base_url: str, + api_key: str, + endpoint: str, + parser: str, + client_type: str = "openai", +) -> list[dict]: + """ + 从提供商 API 获取模型列表 + + Args: + base_url: 提供商的基础 URL + api_key: API 密钥 + endpoint: 获取模型列表的端点 + parser: 响应解析器类型 ('openai' | 'gemini') + client_type: 客户端类型 ('openai' | 'gemini') + + Returns: + 模型列表 + """ + url = f"{_normalize_url(base_url)}{endpoint}" + + # 根据客户端类型设置请求头 + headers = {} + params = {} + + if client_type == "gemini": + # Gemini 使用 URL 参数传递 API Key + params["key"] = api_key + else: + # OpenAI 兼容格式使用 Authorization 头 + headers["Authorization"] = f"Bearer {api_key}" + + try: + async with httpx.AsyncClient(timeout=30.0) as client: + response = await client.get(url, headers=headers, params=params) + response.raise_for_status() + data = response.json() + except httpx.TimeoutException as e: + raise HTTPException(status_code=504, detail="请求超时，请稍后重试") from e + except httpx.HTTPStatusError as e: + # 注意：使用 502 Bad Gateway 而不是原始的 401/403， + # 因为前端的 fetchWithAuth 会把 401 当作 WebUI 认证失败处理 + if e.response.status_code == 401: + raise HTTPException(status_code=502, detail="API Key 无效或已过期") from e + elif e.response.status_code == 403: + raise HTTPException(status_code=502, detail="没有权限访问模型列表，请检查 API Key 权限") from e + elif e.response.status_code == 404: + raise HTTPException(status_code=502, detail="该提供商不支持获取模型列表") from e + else: + raise HTTPException( + status_code=502, detail=f"上游服务请求失败 ({e.response.status_code}): {e.response.text[:200]}" + ) from e + except Exception as e: + logger.error(f"获取模型列表失败: {e}") + raise HTTPException(status_code=500, detail=f"获取模型列表失败: {str(e)}") from e + + # 根据解析器类型解析响应 + if parser == "openai": + return _parse_openai_response(data) + elif parser == "gemini": + return _parse_gemini_response(data) + else: + raise HTTPException(status_code=400, detail=f"不支持的解析器类型: {parser}") + + +def _get_provider_config(provider_name: str) -> Optional[dict]: + """ + 从 model_config.toml 获取指定提供商的配置 + + Args: + provider_name: 提供商名称 + + Returns: + 提供商配置，如果未找到则返回 None + """ + config_path = os.path.join(CONFIG_DIR, "model_config.toml") + if not os.path.exists(config_path): + return None + + try: + with open(config_path, "r", encoding="utf-8") as f: + config_data = tomlkit.load(f) + + providers = config_data.get("api_providers", []) + for provider in providers: + if provider.get("name") == provider_name: + return dict(provider) + + return None + except Exception as e: + logger.error(f"读取提供商配置失败: {e}") + return None + + +@router.get("/list") +async def get_provider_models( + provider_name: str = Query(..., description="提供商名称"), + parser: str = Query("openai", description="响应解析器类型 (openai | gemini)"), + endpoint: str = Query("/models", description="获取模型列表的端点"), + _auth: bool = Depends(require_auth), +): + """ + 获取指定提供商的可用模型列表 + + 通过提供商名称查找配置，然后请求对应的模型列表端点 + """ + # 获取提供商配置 + provider_config = _get_provider_config(provider_name) + if not provider_config: + raise HTTPException(status_code=404, detail=f"未找到提供商: {provider_name}") + + base_url = provider_config.get("base_url") + api_key = provider_config.get("api_key") + client_type = provider_config.get("client_type", "openai") + + if not base_url: + raise HTTPException(status_code=400, detail="提供商配置缺少 base_url") + if not api_key: + raise HTTPException(status_code=400, detail="提供商配置缺少 api_key") + + # 获取模型列表 + models = await _fetch_models_from_provider( + base_url=base_url, + api_key=api_key, + endpoint=endpoint, + parser=parser, + client_type=client_type, + ) + + return { + "success": True, + "models": models, + "provider": provider_name, + "count": len(models), + } + + +@router.get("/list-by-url") +async def get_models_by_url( + base_url: str = Query(..., description="提供商的基础 URL"), + api_key: str = Query(..., description="API Key"), + parser: str = Query("openai", description="响应解析器类型 (openai | gemini)"), + endpoint: str = Query("/models", description="获取模型列表的端点"), + client_type: str = Query("openai", description="客户端类型 (openai | gemini)"), + _auth: bool = Depends(require_auth), +): + """ + 通过 URL 直接获取模型列表（用于自定义提供商） + """ + models = await _fetch_models_from_provider( + base_url=base_url, + api_key=api_key, + endpoint=endpoint, + parser=parser, + client_type=client_type, + ) + + return { + "success": True, + "models": models, + "count": len(models), + } + + +@router.get("/test-connection") +async def test_provider_connection( + base_url: str = Query(..., description="提供商的基础 URL"), + api_key: Optional[str] = Query(None, description="API Key（可选，用于验证 Key 有效性）"), + _auth: bool = Depends(require_auth), +): + """ + 测试提供商连接状态 + + 分两步测试： + 1. 网络连通性测试：向 base_url 发送请求，检查是否能连接 + 2. API Key 验证（可选）：如果提供了 api_key，尝试获取模型列表验证 Key 是否有效 + + 返回： + - network_ok: 网络是否连通 + - api_key_valid: API Key 是否有效（仅在提供 api_key 时返回） + - latency_ms: 响应延迟（毫秒） + - error: 错误信息（如果有） + """ + import time + + base_url = _normalize_url(base_url) + if not base_url: + raise HTTPException(status_code=400, detail="base_url 不能为空") + + result = { + "network_ok": False, + "api_key_valid": None, + "latency_ms": None, + "error": None, + "http_status": None, + } + + # 第一步：测试网络连通性 + try: + start_time = time.time() + async with httpx.AsyncClient(timeout=10.0, follow_redirects=True) as client: + # 尝试 GET 请求 base_url（不需要 API Key） + response = await client.get(base_url) + latency = (time.time() - start_time) * 1000 + + result["network_ok"] = True + result["latency_ms"] = round(latency, 2) + result["http_status"] = response.status_code + + except httpx.ConnectError as e: + result["error"] = f"连接失败：无法连接到服务器 ({str(e)})" + return result + except httpx.TimeoutException: + result["error"] = "连接超时：服务器响应时间过长" + return result + except httpx.RequestError as e: + result["error"] = f"请求错误：{str(e)}" + return result + except Exception as e: + result["error"] = f"未知错误：{str(e)}" + return result + + # 第二步：如果提供了 API Key，验证其有效性 + if api_key: + try: + start_time = time.time() + async with httpx.AsyncClient(timeout=15.0, follow_redirects=True) as client: + headers = { + "Authorization": f"Bearer {api_key}", + "Content-Type": "application/json", + } + # 尝试获取模型列表 + models_url = f"{base_url}/models" + response = await client.get(models_url, headers=headers) + + if response.status_code == 200: + result["api_key_valid"] = True + elif response.status_code in (401, 403): + result["api_key_valid"] = False + result["error"] = "API Key 无效或已过期" + else: + # 其他状态码，可能是端点不支持，但 Key 可能是有效的 + result["api_key_valid"] = None + + except Exception as e: + # API Key 验证失败不影响网络连通性结果 + logger.warning(f"API Key 验证失败: {e}") + result["api_key_valid"] = None + + return result + + +@router.post("/test-connection-by-name") +async def test_provider_connection_by_name( + provider_name: str = Query(..., description="提供商名称"), + _auth: bool = Depends(require_auth), +): + """ + 通过提供商名称测试连接（从配置文件读取信息） + """ + # 读取配置文件 + model_config_path = os.path.join(CONFIG_DIR, "model_config.toml") + if not os.path.exists(model_config_path): + raise HTTPException(status_code=404, detail="配置文件不存在") + + with open(model_config_path, "r", encoding="utf-8") as f: + config = tomlkit.load(f) + + # 查找提供商 + providers = config.get("api_providers", []) + provider = None + for p in providers: + if p.get("name") == provider_name: + provider = p + break + + if not provider: + raise HTTPException(status_code=404, detail=f"未找到提供商: {provider_name}") + + base_url = provider.get("base_url", "") + api_key = provider.get("api_key", "") + + if not base_url: + raise HTTPException(status_code=400, detail="提供商配置缺少 base_url") + + # 调用测试接口 + return await test_provider_connection(base_url=base_url, api_key=api_key if api_key else None) diff --git a/src/webui/person_routes.py b/src/webui/person_routes.py index 5935a2fa..9881d44e 100644 --- a/src/webui/person_routes.py +++ b/src/webui/person_routes.py @@ -1,11 +1,11 @@ """人物信息管理 API 路由""" -from fastapi import APIRouter, HTTPException, Header, Query +from fastapi import APIRouter, HTTPException, Header, Query, Cookie from pydantic import BaseModel from typing import Optional, List, Dict from src.common.logger import get_logger from src.common.database.database_model import PersonInfo -from .token_manager import get_token_manager +from .auth import verify_auth_token_from_cookie_or_header import json import time @@ -91,18 +91,12 @@ class BatchDeleteResponse(BaseModel): failed_ids: List[str] = [] -def verify_auth_token(authorization: Optional[str]) -> bool: - """验证认证 Token""" - if not authorization or not authorization.startswith("Bearer "): - raise HTTPException(status_code=401, detail="未提供有效的认证信息") - - token = authorization.replace("Bearer ", "") - token_manager = get_token_manager() - - if not token_manager.verify_token(token): - raise HTTPException(status_code=401, detail="Token 无效或已过期") - - return True +def verify_auth_token( + maibot_session: Optional[str] = None, + authorization: Optional[str] = None, +) -> bool: + """验证认证 Token，支持 Cookie 和 Header""" + return verify_auth_token_from_cookie_or_header(maibot_session, authorization) def parse_group_nick_name(group_nick_name_str: Optional[str]) -> Optional[List[Dict[str, str]]]: @@ -141,6 +135,7 @@ async def get_person_list( search: Optional[str] = Query(None, description="搜索关键词"), is_known: Optional[bool] = Query(None, description="是否已认识筛选"), platform: Optional[str] = Query(None, description="平台筛选"), + maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None), ): """ @@ -158,7 +153,7 @@ async def get_person_list( 人物信息列表 """ try: - verify_auth_token(authorization) + verify_auth_token(maibot_session, authorization) # 构建查询 query = PersonInfo.select() @@ -205,7 +200,9 @@ async def get_person_list( @router.get("/{person_id}", response_model=PersonDetailResponse) -async def get_person_detail(person_id: str, authorization: Optional[str] = Header(None)): +async def get_person_detail( + person_id: str, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None) +): """ 获取人物详细信息 @@ -217,7 +214,7 @@ async def get_person_detail(person_id: str, authorization: Optional[str] = Heade 人物详细信息 """ try: - verify_auth_token(authorization) + verify_auth_token(maibot_session, authorization) person = PersonInfo.get_or_none(PersonInfo.person_id == person_id) @@ -234,7 +231,12 @@ async def get_person_detail(person_id: str, authorization: Optional[str] = Heade @router.patch("/{person_id}", response_model=PersonUpdateResponse) -async def update_person(person_id: str, request: PersonUpdateRequest, authorization: Optional[str] = Header(None)): +async def update_person( + person_id: str, + request: PersonUpdateRequest, + maibot_session: Optional[str] = Cookie(None), + authorization: Optional[str] = Header(None), +): """ 增量更新人物信息（只更新提供的字段） @@ -247,7 +249,7 @@ async def update_person(person_id: str, request: PersonUpdateRequest, authorizat 更新结果 """ try: - verify_auth_token(authorization) + verify_auth_token(maibot_session, authorization) person = PersonInfo.get_or_none(PersonInfo.person_id == person_id) @@ -283,7 +285,9 @@ async def update_person(person_id: str, request: PersonUpdateRequest, authorizat @router.delete("/{person_id}", response_model=PersonDeleteResponse) -async def delete_person(person_id: str, authorization: Optional[str] = Header(None)): +async def delete_person( + person_id: str, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None) +): """ 删除人物信息 @@ -295,7 +299,7 @@ async def delete_person(person_id: str, authorization: Optional[str] = Header(No 删除结果 """ try: - verify_auth_token(authorization) + verify_auth_token(maibot_session, authorization) person = PersonInfo.get_or_none(PersonInfo.person_id == person_id) @@ -320,7 +324,7 @@ async def delete_person(person_id: str, authorization: Optional[str] = Header(No @router.get("/stats/summary") -async def get_person_stats(authorization: Optional[str] = Header(None)): +async def get_person_stats(maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None)): """ 获取人物信息统计数据 @@ -331,7 +335,7 @@ async def get_person_stats(authorization: Optional[str] = Header(None)): 统计数据 """ try: - verify_auth_token(authorization) + verify_auth_token(maibot_session, authorization) total = PersonInfo.select().count() known = PersonInfo.select().where(PersonInfo.is_known).count() @@ -353,7 +357,11 @@ async def get_person_stats(authorization: Optional[str] = Header(None)): @router.post("/batch/delete", response_model=BatchDeleteResponse) -async def batch_delete_persons(request: BatchDeleteRequest, authorization: Optional[str] = Header(None)): +async def batch_delete_persons( + request: BatchDeleteRequest, + maibot_session: Optional[str] = Cookie(None), + authorization: Optional[str] = Header(None), +): """ 批量删除人物信息 @@ -365,7 +373,7 @@ async def batch_delete_persons(request: BatchDeleteRequest, authorization: Optio 批量删除结果 """ try: - verify_auth_token(authorization) + verify_auth_token(maibot_session, authorization) if not request.person_ids: raise HTTPException(status_code=400, detail="未提供要删除的人物ID") diff --git a/src/webui/plugin_progress_ws.py b/src/webui/plugin_progress_ws.py index 7e0fb647..8d0a18c6 100644 --- a/src/webui/plugin_progress_ws.py +++ b/src/webui/plugin_progress_ws.py @@ -1,10 +1,12 @@ """WebSocket 插件加载进度推送模块""" -from fastapi import APIRouter, WebSocket, WebSocketDisconnect -from typing import Set, Dict, Any +from fastapi import APIRouter, WebSocket, WebSocketDisconnect, Query +from typing import Set, Dict, Any, Optional import json import asyncio from src.common.logger import get_logger +from src.webui.token_manager import get_token_manager +from src.webui.ws_auth import verify_ws_token logger = get_logger("webui.plugin_progress") @@ -89,14 +91,48 @@ async def update_progress( @router.websocket("/ws/plugin-progress") -async def websocket_plugin_progress(websocket: WebSocket): +async def websocket_plugin_progress(websocket: WebSocket, token: Optional[str] = Query(None)): """WebSocket 插件加载进度推送端点 客户端连接后会立即收到当前进度状态 + 支持三种认证方式（按优先级）： + 1. query 参数 token（推荐，通过 /api/webui/ws-token 获取临时 token） + 2. Cookie 中的 maibot_session + 3. 直接使用 session token（兼容） + + 示例：ws://host/ws/plugin-progress?token=xxx """ + is_authenticated = False + + # 方式 1: 尝试验证临时 WebSocket token（推荐方式） + if token and verify_ws_token(token): + is_authenticated = True + logger.debug("插件进度 WebSocket 使用临时 token 认证成功") + + # 方式 2: 尝试从 Cookie 获取 session token + if not is_authenticated: + cookie_token = websocket.cookies.get("maibot_session") + if cookie_token: + token_manager = get_token_manager() + if token_manager.verify_token(cookie_token): + is_authenticated = True + logger.debug("插件进度 WebSocket 使用 Cookie 认证成功") + + # 方式 3: 尝试直接验证 query 参数作为 session token（兼容旧方式） + if not is_authenticated and token: + token_manager = get_token_manager() + if token_manager.verify_token(token): + is_authenticated = True + logger.debug("插件进度 WebSocket 使用 session token 认证成功") + + if not is_authenticated: + logger.warning("插件进度 WebSocket 连接被拒绝：认证失败") + await websocket.close(code=4001, reason="认证失败，请重新登录") + return + await websocket.accept() active_connections.add(websocket) - logger.info(f"📡 插件进度 WebSocket 客户端已连接，当前连接数: {len(active_connections)}") + logger.info(f"📡 插件进度 WebSocket 客户端已连接（已认证），当前连接数: {len(active_connections)}") try: # 发送当前进度状态 diff --git a/src/webui/plugin_routes.py b/src/webui/plugin_routes.py index cb559fb7..df459e5e 100644 --- a/src/webui/plugin_routes.py +++ b/src/webui/plugin_routes.py @@ -1,10 +1,12 @@ -from fastapi import APIRouter, HTTPException, Header +from fastapi import APIRouter, HTTPException, Header, Cookie from pydantic import BaseModel, Field -from typing import Optional, List, Dict, Any +from typing import Optional, List, Dict, Any, get_origin from pathlib import Path import json from src.common.logger import get_logger +from src.common.toml_utils import save_toml_with_format from src.config.config import MMC_VERSION +from src.plugin_system.base.config_types import ConfigField from .git_mirror_service import get_git_mirror_service, set_update_progress_callback from .token_manager import get_token_manager from .plugin_progress_ws import update_progress @@ -18,6 +20,99 @@ router = APIRouter(prefix="/plugins", tags=["插件管理"]) set_update_progress_callback(update_progress) +def get_token_from_cookie_or_header( + maibot_session: Optional[str] = None, + authorization: Optional[str] = None, +) -> Optional[str]: + """从 Cookie 或 Header 获取 token""" + # 优先从 Cookie 获取 + if maibot_session: + return maibot_session + # 其次从 Header 获取 + if authorization and authorization.startswith("Bearer "): + return authorization.replace("Bearer ", "") + return None + + +def validate_safe_path(user_path: str, base_path: Path) -> Path: + """ + 验证用户提供的路径是否安全，防止路径遍历攻击 + + Args: + user_path: 用户输入的路径（相对路径） + base_path: 允许的基础目录 + + Returns: + 安全的绝对路径 + + Raises: + HTTPException: 如果检测到路径遍历攻击 + """ + # 规范化基础路径 + base_resolved = base_path.resolve() + + # 检查用户路径是否包含可疑字符 + # 禁止: .., 绝对路径开头, 空字节等 + if any(pattern in user_path for pattern in ["..", "\x00"]): + logger.warning(f"检测到可疑路径: {user_path}") + raise HTTPException(status_code=400, detail="路径包含非法字符") + + # 检查是否为绝对路径（Windows 和 Unix） + if user_path.startswith("/") or user_path.startswith("\\") or (len(user_path) > 1 and user_path[1] == ":"): + logger.warning(f"检测到绝对路径: {user_path}") + raise HTTPException(status_code=400, detail="不允许使用绝对路径") + + # 构建目标路径并解析 + target_path = (base_path / user_path).resolve() + + # 验证解析后的路径仍在基础目录内 + try: + target_path.relative_to(base_resolved) + except ValueError as e: + logger.warning(f"路径遍历攻击检测: {user_path} -> {target_path}") + raise HTTPException(status_code=400, detail="路径超出允许范围") from e + + return target_path + + +def validate_plugin_id(plugin_id: str) -> str: + """ + 验证插件 ID 格式是否安全 + + Args: + plugin_id: 插件 ID (支持 author.name 格式，允许中文) + + Returns: + 验证通过的插件 ID + + Raises: + HTTPException: 如果插件 ID 格式不安全 + """ + # 禁止空字符串 + if not plugin_id or not plugin_id.strip(): + logger.warning("非法插件 ID: 空字符串") + raise HTTPException(status_code=400, detail="插件 ID 不能为空") + + # 禁止危险字符: 路径分隔符、空字节、控制字符等 + dangerous_patterns = ["/", "\\", "\x00", "..", "\n", "\r", "\t"] + for pattern in dangerous_patterns: + if pattern in plugin_id: + logger.warning(f"非法插件 ID 格式: {plugin_id} (包含危险字符)") + raise HTTPException(status_code=400, detail="插件 ID 包含非法字符") + + # 禁止以点开头或结尾（防止隐藏文件和路径问题） + if plugin_id.startswith(".") or plugin_id.endswith("."): + logger.warning(f"非法插件 ID: {plugin_id}") + raise HTTPException(status_code=400, detail="插件 ID 不能以点开头或结尾") + + # 禁止特殊名称 + if plugin_id in (".", ".."): + logger.warning(f"非法插件 ID: {plugin_id}") + raise HTTPException(status_code=400, detail="插件 ID 不能为特殊目录名") + + return plugin_id + + def parse_version(version_str: str) -> tuple[int, int, int]: """ 解析版本号字符串 @@ -29,8 +124,11 @@ def parse_version(version_str: str) -> tuple[int, int, int]: Returns: (major, minor, patch) 三元组 """ - # 移除 snapshot 等后缀 - base_version = version_str.split(".snapshot")[0].split(".dev")[0].split(".alpha")[0].split(".beta")[0] + # 移除 snapshot、dev、alpha、beta 等后缀（支持 - 和 . 分隔符） + import re + + # 匹配 -snapshot.X, .snapshot, -dev, .dev, -alpha, .alpha, -beta, .beta 等后缀 + base_version = re.split(r"[-.](?:snapshot|dev|alpha|beta|rc)", version_str, flags=re.IGNORECASE)[0] parts = base_version.split(".") if len(parts) < 3: @@ -47,6 +145,95 @@ def parse_version(version_str: str) -> tuple[int, int, int]: return (0, 0, 0) +# ============ 工具函数（避免在请求内重复定义） ============ + + +def _deep_merge(dst: Dict[str, Any], src: Dict[str, Any]) -> None: + """深度合并两个字典，src 的值会覆盖或合并到 dst 中。""" + for k, v in src.items(): + if k in dst and isinstance(dst[k], dict) and isinstance(v, dict): + _deep_merge(dst[k], v) + else: + dst[k] = v + + +def normalize_dotted_keys(obj: Dict[str, Any]) -> Dict[str, Any]: + """ + 将形如 {'a.b': 1} 的键展开为嵌套结构 {'a': {'b': 1}}。 + 若遇到中间节点已存在且非字典，记录日志并覆盖为字典。 + """ + result: Dict[str, Any] = {} + dotted_items = [] + + # 先处理非点号键，避免后续展开覆盖已有结构 + for k, v in obj.items(): + if "." in k: + dotted_items.append((k, v)) + else: + result[k] = normalize_dotted_keys(v) if isinstance(v, dict) else v + + # 再处理点号键 + for dotted_key, v in dotted_items: + value = normalize_dotted_keys(v) if isinstance(v, dict) else v + parts = dotted_key.split(".") + if "" in parts: + logger.warning(f"键路径包含空段: '{dotted_key}'") + parts = [p for p in parts if p] + if not parts: + logger.warning(f"忽略空键路径: '{dotted_key}'") + continue + current = result + # 中间层 + for idx, part in enumerate(parts[:-1]): + if part in current and not isinstance(current[part], dict): + path_ctx = ".".join(parts[: idx + 1]) + logger.warning(f"键冲突：{part} 已存在且非字典，覆盖为字典以展开 {dotted_key} (路径 {path_ctx})") + current[part] = {} + current = current.setdefault(part, {}) + # 最后一层 + last_part = parts[-1] + if last_part in current and isinstance(current[last_part], dict) and isinstance(value, dict): + _deep_merge(current[last_part], value) + else: + current[last_part] = value + + return result + + +def coerce_types(schema_part: Dict[str, Any], config_part: Dict[str, Any]) -> None: + """ + 根据 schema 将配置中的类型纠正（目前只纠正 list-from-str）。 + """ + + def _is_list_type(tp: Any) -> bool: + origin = get_origin(tp) + return tp is list or origin is list + + for key, schema_val in schema_part.items(): + if key not in config_part: + continue + value = config_part[key] + if isinstance(schema_val, ConfigField): + if _is_list_type(schema_val.type) and isinstance(value, str): + config_part[key] = [item.strip() for item in value.split(",") if item.strip()] + elif isinstance(schema_val, dict) and isinstance(value, dict): + coerce_types(schema_val, value) + + +def find_plugin_instance(plugin_id: str) -> Optional[Any]: + """ + 按 plugin_id 或 plugin_name 查找已加载的插件实例。 + 局部导入 plugin_manager 以规避循环依赖。 + """ + from src.plugin_system.core.plugin_manager import plugin_manager + + for loaded_plugin_name in plugin_manager.list_loaded_plugins(): + instance = plugin_manager.get_plugin_instance(loaded_plugin_name) + if instance and (instance.plugin_name == plugin_id or instance.get_manifest_info("id", "") == plugin_id): + return instance + return None + + # ============ 请求/响应模型 ============ @@ -206,12 +393,14 @@ async def check_git_status() -> GitStatusResponse: @router.get("/mirrors", response_model=AvailableMirrorsResponse) -async def get_available_mirrors(authorization: Optional[str] = Header(None)) -> AvailableMirrorsResponse: +async def get_available_mirrors( + maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None) +) -> AvailableMirrorsResponse: """ 获取所有可用的镜像源配置 """ # Token 验证 - token = authorization.replace("Bearer ", "") if authorization else None + token = get_token_from_cookie_or_header(maibot_session, authorization) token_manager = get_token_manager() if not token or not token_manager.verify_token(token): raise HTTPException(status_code=401, detail="未授权：无效的访问令牌") @@ -236,12 +425,14 @@ async def get_available_mirrors(authorization: Optional[str] = Header(None)) -> @router.post("/mirrors", response_model=MirrorConfigResponse) -async def add_mirror(request: AddMirrorRequest, authorization: Optional[str] = Header(None)) -> MirrorConfigResponse: +async def add_mirror( + request: AddMirrorRequest, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None) +) -> MirrorConfigResponse: """ 添加新的镜像源 """ # Token 验证 - token = authorization.replace("Bearer ", "") if authorization else None + token = get_token_from_cookie_or_header(maibot_session, authorization) token_manager = get_token_manager() if not token or not token_manager.verify_token(token): raise HTTPException(status_code=401, detail="未授权：无效的访问令牌") @@ -276,13 +467,16 @@ async def add_mirror(request: AddMirrorRequest, authorization: Optional[str] = H @router.put("/mirrors/{mirror_id}", response_model=MirrorConfigResponse) async def update_mirror( - mirror_id: str, request: UpdateMirrorRequest, authorization: Optional[str] = Header(None) + mirror_id: str, + request: UpdateMirrorRequest, + maibot_session: Optional[str] = Cookie(None), + authorization: Optional[str] = Header(None), ) -> MirrorConfigResponse: """ 更新镜像源配置 """ # Token 验证 - token = authorization.replace("Bearer ", "") if authorization else None + token = get_token_from_cookie_or_header(maibot_session, authorization) token_manager = get_token_manager() if not token or not token_manager.verify_token(token): raise HTTPException(status_code=401, detail="未授权：无效的访问令牌") @@ -319,12 +513,14 @@ async def update_mirror( @router.delete("/mirrors/{mirror_id}") -async def delete_mirror(mirror_id: str, authorization: Optional[str] = Header(None)) -> Dict[str, Any]: +async def delete_mirror( + mirror_id: str, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None) +) -> Dict[str, Any]: """ 删除镜像源 """ # Token 验证 - token = authorization.replace("Bearer ", "") if authorization else None + token = get_token_from_cookie_or_header(maibot_session, authorization) token_manager = get_token_manager() if not token or not token_manager.verify_token(token): raise HTTPException(status_code=401, detail="未授权：无效的访问令牌") @@ -342,26 +538,24 @@ async def delete_mirror(mirror_id: str, authorization: Optional[str] = Header(No @router.post("/fetch-raw", response_model=FetchRawFileResponse) async def fetch_raw_file( - request: FetchRawFileRequest, authorization: Optional[str] = Header(None) + request: FetchRawFileRequest, + maibot_session: Optional[str] = Cookie(None), + authorization: Optional[str] = Header(None), ) -> FetchRawFileResponse: """ 获取 GitHub 仓库的 Raw 文件内容 支持多镜像源自动切换和错误重试 - 注意：此接口可公开访问，用于获取插件仓库等公开资源 + 需要认证才能访问，防止被滥用作为 SSRF 跳板 """ - # Token 验证（可选，用于日志记录） - token = authorization.replace("Bearer ", "") if authorization else None + # Token 验证（强制） + token = get_token_from_cookie_or_header(maibot_session, authorization) token_manager = get_token_manager() - is_authenticated = token and token_manager.verify_token(token) + if not token or not token_manager.verify_token(token): + raise HTTPException(status_code=401, detail="未授权：无效的访问令牌") - # 对于公开仓库的访问，不强制要求认证 - # 只在日志中记录是否认证 - logger.info( - f"收到获取 Raw 文件请求 (认证: {is_authenticated}): " - f"{request.owner}/{request.repo}/{request.branch}/{request.file_path}" - ) + logger.info(f"收到获取 Raw 文件请求: {request.owner}/{request.repo}/{request.branch}/{request.file_path}") # 发送开始加载进度 await update_progress( @@ -427,7 +621,9 @@ async def fetch_raw_file( @router.post("/clone", response_model=CloneRepositoryResponse) async def clone_repository( - request: CloneRepositoryRequest, authorization: Optional[str] = Header(None) + request: CloneRepositoryRequest, + maibot_session: Optional[str] = Cookie(None), + authorization: Optional[str] = Header(None), ) -> CloneRepositoryResponse: """ 克隆 GitHub 仓库到本地 @@ -435,7 +631,7 @@ async def clone_repository( 支持多镜像源自动切换和错误重试 """ # Token 验证 - token = authorization.replace("Bearer ", "") if authorization else None + token = get_token_from_cookie_or_header(maibot_session, authorization) token_manager = get_token_manager() if not token or not token_manager.verify_token(token): raise HTTPException(status_code=401, detail="未授权：无效的访问令牌") @@ -443,10 +639,10 @@ async def clone_repository( logger.info(f"收到克隆仓库请求: {request.owner}/{request.repo} -> {request.target_path}") try: - # TODO: 验证 target_path 的安全性，防止路径遍历攻击 - # TODO: 确定实际的插件目录基路径 - base_plugin_path = Path("./plugins") # 临时路径 - target_path = base_plugin_path / request.target_path + # 验证 target_path 的安全性，防止路径遍历攻击 + base_plugin_path = Path("./plugins").resolve() + base_plugin_path.mkdir(exist_ok=True) + target_path = validate_safe_path(request.target_path, base_plugin_path) service = get_git_mirror_service() result = await service.clone_repository( @@ -467,14 +663,18 @@ async def clone_repository( @router.post("/install") -async def install_plugin(request: InstallPluginRequest, authorization: Optional[str] = Header(None)) -> Dict[str, Any]: +async def install_plugin( + request: InstallPluginRequest, + maibot_session: Optional[str] = Cookie(None), + authorization: Optional[str] = Header(None), +) -> Dict[str, Any]: """ 安装插件 从 Git 仓库克隆插件到本地插件目录 """ # Token 验证 - token = authorization.replace("Bearer ", "") if authorization else None + token = get_token_from_cookie_or_header(maibot_session, authorization) token_manager = get_token_manager() if not token or not token_manager.verify_token(token): raise HTTPException(status_code=401, detail="未授权：无效的访问令牌") @@ -482,13 +682,16 @@ async def install_plugin(request: InstallPluginRequest, authorization: Optional[ logger.info(f"收到安装插件请求: {request.plugin_id}") try: + # 验证插件 ID 格式安全性 + plugin_id = validate_plugin_id(request.plugin_id) + # 推送进度：开始安装 await update_progress( stage="loading", progress=5, - message=f"开始安装插件: {request.plugin_id}", + message=f"开始安装插件: {plugin_id}", operation="install", - plugin_id=request.plugin_id, + plugin_id=plugin_id, ) # 1. 解析仓库 URL @@ -509,23 +712,28 @@ async def install_plugin(request: InstallPluginRequest, authorization: Optional[ progress=10, message=f"解析仓库信息: {owner}/{repo}", operation="install", - plugin_id=request.plugin_id, + plugin_id=plugin_id, ) # 2. 确定插件安装路径 - plugins_dir = Path("plugins") + plugins_dir = Path("plugins").resolve() plugins_dir.mkdir(exist_ok=True) - target_path = plugins_dir / request.plugin_id + # 将插件 ID 中的点替换为下划线作为文件夹名称（避免文件系统问题） + # 例如: SengokuCola.Mute-Plugin -> SengokuCola_Mute-Plugin + folder_name = plugin_id.replace(".", "_") + # 使用安全路径验证，防止路径遍历 + target_path = validate_safe_path(folder_name, plugins_dir) - # 检查插件是否已安装 - if target_path.exists(): + # 检查插件是否已安装（需要检查两种格式：新格式下划线和旧格式点） + old_format_path = plugins_dir / plugin_id + if target_path.exists() or old_format_path.exists(): await update_progress( stage="error", progress=0, message="插件已存在", operation="install", - plugin_id=request.plugin_id, + plugin_id=plugin_id, error="插件已安装，请先卸载", ) raise HTTPException(status_code=400, detail="插件已安装") @@ -535,7 +743,7 @@ async def install_plugin(request: InstallPluginRequest, authorization: Optional[ progress=15, message=f"准备克隆到: {target_path}", operation="install", - plugin_id=request.plugin_id, + plugin_id=plugin_id, ) # 3. 克隆仓库（这里会自动推送 20%-80% 的进度） @@ -564,14 +772,14 @@ async def install_plugin(request: InstallPluginRequest, authorization: Optional[ progress=0, message="克隆仓库失败", operation="install", - plugin_id=request.plugin_id, + plugin_id=plugin_id, error=error_msg, ) raise HTTPException(status_code=500, detail=error_msg) # 4. 验证插件完整性 await update_progress( - stage="loading", progress=85, message="验证插件文件...", operation="install", plugin_id=request.plugin_id + stage="loading", progress=85, message="验证插件文件...", operation="install", plugin_id=plugin_id ) manifest_path = target_path / "_manifest.json" @@ -586,14 +794,14 @@ async def install_plugin(request: InstallPluginRequest, authorization: Optional[ progress=0, message="插件缺少 _manifest.json", operation="install", - plugin_id=request.plugin_id, + plugin_id=plugin_id, error="无效的插件格式", ) raise HTTPException(status_code=400, detail="无效的插件：缺少 _manifest.json") # 5. 读取并验证 manifest await update_progress( - stage="loading", progress=90, message="读取插件配置...", operation="install", plugin_id=request.plugin_id + stage="loading", progress=90, message="读取插件配置...", operation="install", plugin_id=plugin_id ) try: @@ -608,6 +816,12 @@ async def install_plugin(request: InstallPluginRequest, authorization: Optional[ if field not in manifest: raise ValueError(f"缺少必需字段: {field}") + # 将插件 ID 写入 manifest（用于后续准确识别） + # 这样即使文件夹名称改变，也能通过 manifest 准确识别插件 + manifest["id"] = plugin_id + with open(manifest_path, "w", encoding="utf-8") as f: + json_module.dump(manifest, f, ensure_ascii=False, indent=2) + except Exception as e: # 清理失败的安装 import shutil @@ -619,7 +833,7 @@ async def install_plugin(request: InstallPluginRequest, authorization: Optional[ progress=0, message="_manifest.json 无效", operation="install", - plugin_id=request.plugin_id, + plugin_id=plugin_id, error=str(e), ) raise HTTPException(status_code=400, detail=f"无效的 _manifest.json: {e}") from e @@ -630,13 +844,13 @@ async def install_plugin(request: InstallPluginRequest, authorization: Optional[ progress=100, message=f"成功安装插件: {manifest['name']} v{manifest['version']}", operation="install", - plugin_id=request.plugin_id, + plugin_id=plugin_id, ) return { "success": True, "message": "插件安装成功", - "plugin_id": request.plugin_id, + "plugin_id": plugin_id, "plugin_name": manifest["name"], "version": manifest["version"], "path": str(target_path), @@ -652,7 +866,7 @@ async def install_plugin(request: InstallPluginRequest, authorization: Optional[ progress=0, message="安装失败", operation="install", - plugin_id=request.plugin_id, + plugin_id=plugin_id, error=str(e), ) @@ -661,7 +875,9 @@ async def install_plugin(request: InstallPluginRequest, authorization: Optional[ @router.post("/uninstall") async def uninstall_plugin( - request: UninstallPluginRequest, authorization: Optional[str] = Header(None) + request: UninstallPluginRequest, + maibot_session: Optional[str] = Cookie(None), + authorization: Optional[str] = Header(None), ) -> Dict[str, Any]: """ 卸载插件 @@ -669,7 +885,7 @@ async def uninstall_plugin( 删除插件目录及其所有文件 """ # Token 验证 - token = authorization.replace("Bearer ", "") if authorization else None + token = get_token_from_cookie_or_header(maibot_session, authorization) token_manager = get_token_manager() if not token or not token_manager.verify_token(token): raise HTTPException(status_code=401, detail="未授权：无效的访问令牌") @@ -677,41 +893,53 @@ async def uninstall_plugin( logger.info(f"收到卸载插件请求: {request.plugin_id}") try: + # 验证插件 ID 格式安全性 + plugin_id = validate_plugin_id(request.plugin_id) + # 推送进度：开始卸载 await update_progress( stage="loading", progress=10, - message=f"开始卸载插件: {request.plugin_id}", + message=f"开始卸载插件: {plugin_id}", operation="uninstall", - plugin_id=request.plugin_id, + plugin_id=plugin_id, ) - # 1. 检查插件是否存在 - plugins_dir = Path("plugins") - plugin_path = plugins_dir / request.plugin_id + # 1. 检查插件是否存在（支持新旧两种格式） + plugins_dir = Path("plugins").resolve() + # 新格式：下划线 + folder_name = plugin_id.replace(".", "_") + # 使用安全路径验证 + plugin_path = validate_safe_path(folder_name, plugins_dir) + # 旧格式：点 + old_format_path = validate_safe_path(plugin_id, plugins_dir) + # 优先使用新格式，如果不存在则尝试旧格式 if not plugin_path.exists(): - await update_progress( - stage="error", - progress=0, - message="插件不存在", - operation="uninstall", - plugin_id=request.plugin_id, - error="插件未安装或已被删除", - ) - raise HTTPException(status_code=404, detail="插件未安装") + if old_format_path.exists(): + plugin_path = old_format_path + else: + await update_progress( + stage="error", + progress=0, + message="插件不存在", + operation="uninstall", + plugin_id=plugin_id, + error="插件未安装或已被删除", + ) + raise HTTPException(status_code=404, detail="插件未安装") await update_progress( stage="loading", progress=30, message=f"正在删除插件文件: {plugin_path}", operation="uninstall", - plugin_id=request.plugin_id, + plugin_id=plugin_id, ) # 2. 读取插件信息（用于日志） manifest_path = plugin_path / "_manifest.json" - plugin_name = request.plugin_id + plugin_name = plugin_id if manifest_path.exists(): try: @@ -719,7 +947,7 @@ async def uninstall_plugin( with open(manifest_path, "r", encoding="utf-8") as f: manifest = json_module.load(f) - plugin_name = manifest.get("name", request.plugin_id) + plugin_name = manifest.get("name", plugin_id) except Exception: pass # 如果读取失败，使用插件 ID 作为名称 @@ -728,7 +956,7 @@ async def uninstall_plugin( progress=50, message=f"正在删除 {plugin_name}...", operation="uninstall", - plugin_id=request.plugin_id, + plugin_id=plugin_id, ) # 3. 删除插件目录 @@ -744,7 +972,7 @@ async def uninstall_plugin( shutil.rmtree(plugin_path, onerror=remove_readonly) - logger.info(f"成功卸载插件: {request.plugin_id} ({plugin_name})") + logger.info(f"成功卸载插件: {plugin_id} ({plugin_name})") # 4. 推送成功状态 await update_progress( @@ -752,10 +980,10 @@ async def uninstall_plugin( progress=100, message=f"成功卸载插件: {plugin_name}", operation="uninstall", - plugin_id=request.plugin_id, + plugin_id=plugin_id, ) - return {"success": True, "message": "插件卸载成功", "plugin_id": request.plugin_id, "plugin_name": plugin_name} + return {"success": True, "message": "插件卸载成功", "plugin_id": plugin_id, "plugin_name": plugin_name} except HTTPException: raise @@ -767,7 +995,7 @@ async def uninstall_plugin( progress=0, message="卸载失败", operation="uninstall", - plugin_id=request.plugin_id, + plugin_id=plugin_id, error="权限不足，无法删除插件文件", ) @@ -780,7 +1008,7 @@ async def uninstall_plugin( progress=0, message="卸载失败", operation="uninstall", - plugin_id=request.plugin_id, + plugin_id=plugin_id, error=str(e), ) @@ -788,14 +1016,18 @@ async def uninstall_plugin( @router.post("/update") -async def update_plugin(request: UpdatePluginRequest, authorization: Optional[str] = Header(None)) -> Dict[str, Any]: +async def update_plugin( + request: UpdatePluginRequest, + maibot_session: Optional[str] = Cookie(None), + authorization: Optional[str] = Header(None), +) -> Dict[str, Any]: """ 更新插件 删除旧版本，重新克隆新版本 """ # Token 验证 - token = authorization.replace("Bearer ", "") if authorization else None + token = get_token_from_cookie_or_header(maibot_session, authorization) token_manager = get_token_manager() if not token or not token_manager.verify_token(token): raise HTTPException(status_code=401, detail="未授权：无效的访问令牌") @@ -803,34 +1035,45 @@ async def update_plugin(request: UpdatePluginRequest, authorization: Optional[st logger.info(f"收到更新插件请求: {request.plugin_id}") try: + # 验证插件 ID 格式安全性 + plugin_id = validate_plugin_id(request.plugin_id) + # 推送进度：开始更新 await update_progress( stage="loading", progress=5, - message=f"开始更新插件: {request.plugin_id}", + message=f"开始更新插件: {plugin_id}", operation="update", - plugin_id=request.plugin_id, + plugin_id=plugin_id, ) - # 1. 检查插件是否已安装 - plugins_dir = Path("plugins") - plugin_path = plugins_dir / request.plugin_id + # 1. 检查插件是否已安装（支持新旧两种格式） + plugins_dir = Path("plugins").resolve() + # 新格式：下划线 + folder_name = plugin_id.replace(".", "_") + # 使用安全路径验证 + plugin_path = validate_safe_path(folder_name, plugins_dir) + # 旧格式：点 + old_format_path = validate_safe_path(plugin_id, plugins_dir) + # 优先使用新格式，如果不存在则尝试旧格式 if not plugin_path.exists(): - await update_progress( - stage="error", - progress=0, - message="插件不存在", - operation="update", - plugin_id=request.plugin_id, - error="插件未安装，请先安装", - ) - raise HTTPException(status_code=404, detail="插件未安装") + if old_format_path.exists(): + plugin_path = old_format_path + else: + await update_progress( + stage="error", + progress=0, + message="插件不存在", + operation="update", + plugin_id=plugin_id, + error="插件未安装，请先安装", + ) + raise HTTPException(status_code=404, detail="插件未安装") # 2. 读取旧版本信息 manifest_path = plugin_path / "_manifest.json" old_version = "unknown" - plugin_name = request.plugin_id if manifest_path.exists(): try: @@ -839,7 +1082,6 @@ async def update_plugin(request: UpdatePluginRequest, authorization: Optional[st with open(manifest_path, "r", encoding="utf-8") as f: manifest = json_module.load(f) old_version = manifest.get("version", "unknown") - _plugin_name = manifest.get("name", request.plugin_id) except Exception: pass @@ -848,12 +1090,12 @@ async def update_plugin(request: UpdatePluginRequest, authorization: Optional[st progress=10, message=f"当前版本: {old_version}，准备更新...", operation="update", - plugin_id=request.plugin_id, + plugin_id=plugin_id, ) # 3. 删除旧版本 await update_progress( - stage="loading", progress=20, message="正在删除旧版本...", operation="update", plugin_id=request.plugin_id + stage="loading", progress=20, message="正在删除旧版本...", operation="update", plugin_id=plugin_id ) import shutil @@ -868,7 +1110,7 @@ async def update_plugin(request: UpdatePluginRequest, authorization: Optional[st shutil.rmtree(plugin_path, onerror=remove_readonly) - logger.info(f"已删除旧版本: {request.plugin_id} v{old_version}") + logger.info(f"已删除旧版本: {plugin_id} v{old_version}") # 4. 解析仓库 URL await update_progress( @@ -876,7 +1118,7 @@ async def update_plugin(request: UpdatePluginRequest, authorization: Optional[st progress=30, message="正在准备下载新版本...", operation="update", - plugin_id=request.plugin_id, + plugin_id=plugin_id, ) repo_url = request.repository_url.rstrip("/") @@ -914,14 +1156,14 @@ async def update_plugin(request: UpdatePluginRequest, authorization: Optional[st progress=0, message="下载新版本失败", operation="update", - plugin_id=request.plugin_id, + plugin_id=plugin_id, error=error_msg, ) raise HTTPException(status_code=500, detail=error_msg) # 6. 验证新版本 await update_progress( - stage="loading", progress=90, message="验证新版本...", operation="update", plugin_id=request.plugin_id + stage="loading", progress=90, message="验证新版本...", operation="update", plugin_id=plugin_id ) new_manifest_path = plugin_path / "_manifest.json" @@ -941,7 +1183,7 @@ async def update_plugin(request: UpdatePluginRequest, authorization: Optional[st progress=0, message="新版本缺少 _manifest.json", operation="update", - plugin_id=request.plugin_id, + plugin_id=plugin_id, error="无效的插件格式", ) raise HTTPException(status_code=400, detail="无效的插件：缺少 _manifest.json") @@ -952,9 +1194,9 @@ async def update_plugin(request: UpdatePluginRequest, authorization: Optional[st new_manifest = json_module.load(f) new_version = new_manifest.get("version", "unknown") - new_name = new_manifest.get("name", request.plugin_id) + new_name = new_manifest.get("name", plugin_id) - logger.info(f"成功更新插件: {request.plugin_id} {old_version} → {new_version}") + logger.info(f"成功更新插件: {plugin_id} {old_version} → {new_version}") # 8. 推送成功状态 await update_progress( @@ -962,13 +1204,13 @@ async def update_plugin(request: UpdatePluginRequest, authorization: Optional[st progress=100, message=f"成功更新 {new_name}: {old_version} → {new_version}", operation="update", - plugin_id=request.plugin_id, + plugin_id=plugin_id, ) return { "success": True, "message": "插件更新成功", - "plugin_id": request.plugin_id, + "plugin_id": plugin_id, "plugin_name": new_name, "old_version": old_version, "new_version": new_version, @@ -983,7 +1225,7 @@ async def update_plugin(request: UpdatePluginRequest, authorization: Optional[st progress=0, message="_manifest.json 无效", operation="update", - plugin_id=request.plugin_id, + plugin_id=plugin_id, error=str(e), ) raise HTTPException(status_code=400, detail=f"无效的 _manifest.json: {e}") from e @@ -994,21 +1236,23 @@ async def update_plugin(request: UpdatePluginRequest, authorization: Optional[st logger.error(f"更新插件失败: {e}", exc_info=True) await update_progress( - stage="error", progress=0, message="更新失败", operation="update", plugin_id=request.plugin_id, error=str(e) + stage="error", progress=0, message="更新失败", operation="update", plugin_id=plugin_id, error=str(e) ) raise HTTPException(status_code=500, detail=f"服务器错误: {str(e)}") from e @router.get("/installed") -async def get_installed_plugins(authorization: Optional[str] = Header(None)) -> Dict[str, Any]: +async def get_installed_plugins( + maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None) +) -> Dict[str, Any]: """ 获取已安装的插件列表 扫描 plugins 目录，返回所有已安装插件的 ID 和基本信息 """ # Token 验证 - token = authorization.replace("Bearer ", "") if authorization else None + token = get_token_from_cookie_or_header(maibot_session, authorization) token_manager = get_token_manager() if not token or not token_manager.verify_token(token): raise HTTPException(status_code=401, detail="未授权：无效的访问令牌") @@ -1032,18 +1276,18 @@ async def get_installed_plugins(authorization: Optional[str] = Header(None)) -> if not plugin_path.is_dir(): continue - # 目录名即为插件 ID - plugin_id = plugin_path.name + # 目录名（可能是下划线格式、点格式或其他格式） + folder_name = plugin_path.name # 跳过隐藏目录和特殊目录 - if plugin_id.startswith(".") or plugin_id.startswith("__"): + if folder_name.startswith(".") or folder_name.startswith("__"): continue # 读取 _manifest.json manifest_path = plugin_path / "_manifest.json" if not manifest_path.exists(): - logger.warning(f"插件 {plugin_id} 缺少 _manifest.json，跳过") + logger.warning(f"插件文件夹 {folder_name} 缺少 _manifest.json，跳过") continue try: @@ -1054,9 +1298,58 @@ async def get_installed_plugins(authorization: Optional[str] = Header(None)) -> # 基本验证 if "name" not in manifest or "version" not in manifest: - logger.warning(f"插件 {plugin_id} 的 _manifest.json 格式无效，跳过") + logger.warning(f"插件文件夹 {folder_name} 的 _manifest.json 格式无效，跳过") continue + # 获取插件 ID（优先从 manifest，否则从文件夹名推断） + if "id" in manifest: + # 优先使用 manifest 中的 id（最准确） + plugin_id = manifest["id"] + else: + # 从 manifest 信息构建 ID + # 尝试从 author.name 和 repository_url 构建标准 ID + author_name = None + repo_name = None + + # 获取作者名 + if "author" in manifest: + if isinstance(manifest["author"], dict) and "name" in manifest["author"]: + author_name = manifest["author"]["name"] + elif isinstance(manifest["author"], str): + author_name = manifest["author"] + + # 从 repository_url 获取仓库名 + if "repository_url" in manifest: + repo_url = manifest["repository_url"].rstrip("/") + if repo_url.endswith(".git"): + repo_url = repo_url[:-4] + repo_name = repo_url.split("/")[-1] + + # 构建 ID + if author_name and repo_name: + # 标准格式: Author.RepoName + plugin_id = f"{author_name}.{repo_name}" + elif author_name: + # 如果只有作者，使用 Author.FolderName + plugin_id = f"{author_name}.{folder_name}" + else: + # 从文件夹名推断 + if "_" in folder_name and "." not in folder_name: + # 假设格式为 Author_PluginName，转换为 Author.PluginName + plugin_id = folder_name.replace("_", ".", 1) + else: + # 直接使用文件夹名 + plugin_id = folder_name + + # 将推断的 ID 写入 manifest（方便下次识别） + logger.info(f"为插件 {folder_name} 自动生成 ID: {plugin_id}") + manifest["id"] = plugin_id + try: + with open(manifest_path, "w", encoding="utf-8") as f: + json_module.dump(manifest, f, ensure_ascii=False, indent=2) + except Exception as write_error: + logger.warning(f"无法写入 ID 到 manifest: {write_error}") + # 添加到已安装列表（返回完整的 manifest 信息） installed_plugins.append( { @@ -1067,16 +1360,628 @@ async def get_installed_plugins(authorization: Optional[str] = Header(None)) -> ) except json.JSONDecodeError as e: - logger.warning(f"插件 {plugin_id} 的 _manifest.json 解析失败: {e}") + logger.warning(f"插件 {folder_name} 的 _manifest.json 解析失败: {e}") continue except Exception as e: - logger.error(f"读取插件 {plugin_id} 信息时出错: {e}") + logger.error(f"读取插件 {folder_name} 信息时出错: {e}") continue - logger.info(f"找到 {len(installed_plugins)} 个已安装插件") + # 去重：如果有重复的 plugin_id，只保留第一个（按路径） + seen_ids = {} # 记录 ID -> 路径的映射 + unique_plugins = [] + duplicates = [] + + for plugin in installed_plugins: + plugin_id = plugin["id"] + plugin_path = plugin["path"] + + if plugin_id not in seen_ids: + seen_ids[plugin_id] = plugin_path + unique_plugins.append(plugin) + else: + duplicates.append(plugin) + first_path = seen_ids[plugin_id] + logger.warning( + f"重复插件 {plugin_id}: 保留 {first_path}, 跳过 {plugin_path}" + ) + + if duplicates: + logger.warning(f"共检测到 {len(duplicates)} 个重复插件已去重") - return {"success": True, "plugins": installed_plugins, "total": len(installed_plugins)} + logger.info(f"找到 {len(unique_plugins)} 个已安装插件") + + return {"success": True, "plugins": unique_plugins, "total": len(unique_plugins)} except Exception as e: logger.error(f"获取已安装插件列表失败: {e}", exc_info=True) raise HTTPException(status_code=500, detail=f"服务器错误: {str(e)}") from e + + +# ============ 插件配置管理 API ============ + + +class UpdatePluginConfigRequest(BaseModel): + """更新插件配置请求""" + + config: Dict[str, Any] = Field(..., description="配置数据") + + +@router.get("/config/{plugin_id}/schema") +async def get_plugin_config_schema( + plugin_id: str, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None) +) -> Dict[str, Any]: + """ + 获取插件配置 Schema + + 返回插件的完整配置 schema，包含所有 section、字段定义和布局信息。 + 用于前端动态生成配置表单。 + """ + # Token 验证 + token = get_token_from_cookie_or_header(maibot_session, authorization) + token_manager = get_token_manager() + if not token or not token_manager.verify_token(token): + raise HTTPException(status_code=401, detail="未授权：无效的访问令牌") + + logger.info(f"获取插件配置 Schema: {plugin_id}") + + try: + # 尝试从已加载的插件中获取 + from src.plugin_system.core.plugin_manager import plugin_manager + + # 查找插件实例 + plugin_instance = None + + # 遍历所有已加载的插件 + for loaded_plugin_name in plugin_manager.list_loaded_plugins(): + instance = plugin_manager.get_plugin_instance(loaded_plugin_name) + if instance: + # 匹配 plugin_name 或 manifest 中的 id + if instance.plugin_name == plugin_id: + plugin_instance = instance + break + # 也尝试匹配 manifest 中的 id + manifest_id = instance.get_manifest_info("id", "") + if manifest_id == plugin_id: + plugin_instance = instance + break + + if plugin_instance and hasattr(plugin_instance, "get_webui_config_schema"): + # 从插件实例获取 schema + schema = plugin_instance.get_webui_config_schema() + return {"success": True, "schema": schema} + + # 如果插件未加载，尝试从文件系统读取 + # 查找插件目录 + plugins_dir = Path("plugins") + plugin_path = None + + for p in plugins_dir.iterdir(): + if p.is_dir(): + manifest_path = p / "_manifest.json" + if manifest_path.exists(): + try: + with open(manifest_path, "r", encoding="utf-8") as f: + manifest = json.load(f) + if manifest.get("id") == plugin_id or p.name == plugin_id: + plugin_path = p + break + except Exception: + continue + + if not plugin_path: + raise HTTPException(status_code=404, detail=f"未找到插件: {plugin_id}") + + # 读取配置文件获取当前配置 + config_path = plugin_path / "config.toml" + current_config = {} + if config_path.exists(): + import tomlkit + + with open(config_path, "r", encoding="utf-8") as f: + current_config = tomlkit.load(f) + + # 构建基础 schema（无法获取完整的 ConfigField 信息） + schema = { + "plugin_id": plugin_id, + "plugin_info": { + "name": plugin_id, + "version": "", + "description": "", + "author": "", + }, + "sections": {}, + "layout": {"type": "auto", "tabs": []}, + "_note": "插件未加载，仅返回当前配置结构", + } + + # 从当前配置推断 schema + for section_name, section_data in current_config.items(): + if isinstance(section_data, dict): + schema["sections"][section_name] = { + "name": section_name, + "title": section_name, + "description": None, + "icon": None, + "collapsed": False, + "order": 0, + "fields": {}, + } + for field_name, field_value in section_data.items(): + # 推断字段类型 + field_type = type(field_value).__name__ + ui_type = "text" + item_type = None + item_fields = None + + if isinstance(field_value, bool): + ui_type = "switch" + elif isinstance(field_value, (int, float)): + ui_type = "number" + elif isinstance(field_value, list): + ui_type = "list" + # 推断数组元素类型 + if field_value: + first_item = field_value[0] + if isinstance(first_item, dict): + item_type = "object" + # 从第一个元素推断字段结构 + item_fields = {} + for k, v in first_item.items(): + item_fields[k] = { + "type": "number" if isinstance(v, (int, float)) else "string", + "label": k, + "default": "" if isinstance(v, str) else 0, + } + elif isinstance(first_item, (int, float)): + item_type = "number" + else: + item_type = "string" + else: + item_type = "string" + elif isinstance(field_value, dict): + ui_type = "json" + + schema["sections"][section_name]["fields"][field_name] = { + "name": field_name, + "type": field_type, + "default": field_value, + "description": field_name, + "label": field_name, + "ui_type": ui_type, + "required": False, + "hidden": False, + "disabled": False, + "order": 0, + "item_type": item_type, + "item_fields": item_fields, + "min_items": None, + "max_items": None, + # 补充缺失的字段 + "placeholder": None, + "hint": None, + "icon": None, + "example": None, + "choices": None, + "min": None, + "max": None, + "step": None, + "pattern": None, + "max_length": None, + "input_type": None, + "rows": 3, + "group": None, + "depends_on": None, + "depends_value": None, + } + + return {"success": True, "schema": schema} + + except HTTPException: + raise + except Exception as e: + logger.error(f"获取插件配置 Schema 失败: {e}", exc_info=True) + raise HTTPException(status_code=500, detail=f"服务器错误: {str(e)}") from e + + +@router.get("/config/{plugin_id}/raw") +async def get_plugin_config_raw( + plugin_id: str, + maibot_session: Optional[str] = Cookie(None), + authorization: Optional[str] = Header(None), +) -> Dict[str, Any]: + """ + 获取插件原始 TOML 配置文件内容 + """ + # Token 验证 + token = get_token_from_cookie_or_header(maibot_session, authorization) + token_manager = get_token_manager() + if not token or not token_manager.verify_token(token): + raise HTTPException(status_code=401, detail="未授权：无效的访问令牌") + + logger.info(f"获取插件原始配置: {plugin_id}") + + try: + # 查找插件目录 + plugins_dir = Path("plugins") + plugin_path = None + + for p in plugins_dir.iterdir(): + if p.is_dir(): + manifest_path = p / "_manifest.json" + if manifest_path.exists(): + try: + with open(manifest_path, "r", encoding="utf-8") as f: + manifest = json.load(f) + if manifest.get("id") == plugin_id or p.name == plugin_id: + plugin_path = p + break + except Exception: + continue + + if not plugin_path: + raise HTTPException(status_code=404, detail=f"未找到插件: {plugin_id}") + + # 读取配置文件 + config_path = plugin_path / "config.toml" + if not config_path.exists(): + return {"success": True, "config": "", "message": "配置文件不存在"} + + with open(config_path, "r", encoding="utf-8") as f: + config_content = f.read() + + return {"success": True, "config": config_content} + + except HTTPException: + raise + except Exception as e: + logger.error(f"获取插件原始配置失败: {e}", exc_info=True) + raise HTTPException(status_code=500, detail=f"服务器错误: {str(e)}") from e + + +@router.put("/config/{plugin_id}/raw") +async def update_plugin_config_raw( + plugin_id: str, + request: UpdatePluginConfigRequest, + maibot_session: Optional[str] = Cookie(None), + authorization: Optional[str] = Header(None), +) -> Dict[str, Any]: + """ + 更新插件原始 TOML 配置文件 + + 直接保存 TOML 字符串到配置文件。 + """ + # Token 验证 + token = get_token_from_cookie_or_header(maibot_session, authorization) + token_manager = get_token_manager() + if not token or not token_manager.verify_token(token): + raise HTTPException(status_code=401, detail="未授权：无效的访问令牌") + + logger.info(f"更新插件原始配置: {plugin_id}") + + try: + # 查找插件目录 + plugins_dir = Path("plugins") + plugin_path = None + + for p in plugins_dir.iterdir(): + if p.is_dir(): + manifest_path = p / "_manifest.json" + if manifest_path.exists(): + try: + with open(manifest_path, "r", encoding="utf-8") as f: + manifest = json.load(f) + if manifest.get("id") == plugin_id or p.name == plugin_id: + plugin_path = p + break + except Exception: + continue + + if not plugin_path: + raise HTTPException(status_code=404, detail=f"未找到插件: {plugin_id}") + + config_path = plugin_path / "config.toml" + + # 验证 TOML 格式 + import tomlkit + + if not isinstance(request.config, str): + raise HTTPException(status_code=400, detail="配置必须是字符串格式的 TOML 内容") + + try: + tomlkit.loads(request.config) + except Exception as e: + raise HTTPException(status_code=400, detail=f"TOML 格式错误: {str(e)}") + + # 备份旧配置 + import shutil + import datetime + + if config_path.exists(): + backup_name = f"config.toml.backup.{datetime.datetime.now().strftime('%Y%m%d%H%M%S')}" + backup_path = plugin_path / backup_name + shutil.copy(config_path, backup_path) + logger.info(f"已备份配置文件: {backup_path}") + + # 写入新配置 + with open(config_path, "w", encoding="utf-8") as f: + f.write(request.config) + + logger.info(f"已更新插件原始配置: {plugin_id}") + + return {"success": True, "message": "配置已保存", "note": "配置更改将在插件重新加载后生效"} + + except HTTPException: + raise + except Exception as e: + logger.error(f"更新插件原始配置失败: {e}", exc_info=True) + raise HTTPException(status_code=500, detail=f"服务器错误: {str(e)}") from e + + +@router.get("/config/{plugin_id}") +async def get_plugin_config( + plugin_id: str, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None) +) -> Dict[str, Any]: + """ + 获取插件当前配置值 + + 返回插件的当前配置值。 + """ + # Token 验证 + token = get_token_from_cookie_or_header(maibot_session, authorization) + token_manager = get_token_manager() + if not token or not token_manager.verify_token(token): + raise HTTPException(status_code=401, detail="未授权：无效的访问令牌") + + logger.info(f"获取插件配置: {plugin_id}") + + try: + # 查找插件目录 + plugins_dir = Path("plugins") + plugin_path = None + + for p in plugins_dir.iterdir(): + if p.is_dir(): + manifest_path = p / "_manifest.json" + if manifest_path.exists(): + try: + with open(manifest_path, "r", encoding="utf-8") as f: + manifest = json.load(f) + if manifest.get("id") == plugin_id or p.name == plugin_id: + plugin_path = p + break + except Exception: + continue + + if not plugin_path: + raise HTTPException(status_code=404, detail=f"未找到插件: {plugin_id}") + + # 读取配置文件 + config_path = plugin_path / "config.toml" + if not config_path.exists(): + return {"success": True, "config": {}, "message": "配置文件不存在"} + + import tomlkit + + with open(config_path, "r", encoding="utf-8") as f: + config = tomlkit.load(f) + + return {"success": True, "config": dict(config)} + + except HTTPException: + raise + except Exception as e: + logger.error(f"获取插件配置失败: {e}", exc_info=True) + raise HTTPException(status_code=500, detail=f"服务器错误: {str(e)}") from e + + +@router.put("/config/{plugin_id}") +async def update_plugin_config( + plugin_id: str, + request: UpdatePluginConfigRequest, + maibot_session: Optional[str] = Cookie(None), + authorization: Optional[str] = Header(None), +) -> Dict[str, Any]: + """ + 更新插件配置 + + 保存新的配置值到插件的配置文件。 + """ + # Token 验证 + token = get_token_from_cookie_or_header(maibot_session, authorization) + token_manager = get_token_manager() + if not token or not token_manager.verify_token(token): + raise HTTPException(status_code=401, detail="未授权：无效的访问令牌") + + logger.info(f"更新插件配置: {plugin_id}") + + try: + plugin_instance = find_plugin_instance(plugin_id) + + # 纠正 WebUI 提交的数据结构（扁平键与字符串列表） + if plugin_instance and isinstance(request.config, dict): + request.config = normalize_dotted_keys(request.config) + if isinstance(plugin_instance.config_schema, dict): + coerce_types(plugin_instance.config_schema, request.config) + + # 查找插件目录 + plugins_dir = Path("plugins") + plugin_path = None + + for p in plugins_dir.iterdir(): + if p.is_dir(): + manifest_path = p / "_manifest.json" + if manifest_path.exists(): + try: + with open(manifest_path, "r", encoding="utf-8") as f: + manifest = json.load(f) + if manifest.get("id") == plugin_id or p.name == plugin_id: + plugin_path = p + break + except Exception: + continue + + if not plugin_path: + raise HTTPException(status_code=404, detail=f"未找到插件: {plugin_id}") + + config_path = plugin_path / "config.toml" + + # 备份旧配置 + import shutil + import datetime + + if config_path.exists(): + backup_name = f"config.toml.backup.{datetime.datetime.now().strftime('%Y%m%d%H%M%S')}" + backup_path = plugin_path / backup_name + shutil.copy(config_path, backup_path) + logger.info(f"已备份配置文件: {backup_path}") + + # 写入新配置（自动保留注释和格式） + save_toml_with_format(request.config, str(config_path)) + + logger.info(f"已更新插件配置: {plugin_id}") + + return {"success": True, "message": "配置已保存", "note": "配置更改将在插件重新加载后生效"} + + except HTTPException: + raise + except Exception as e: + logger.error(f"更新插件配置失败: {e}", exc_info=True) + raise HTTPException(status_code=500, detail=f"服务器错误: {str(e)}") from e + + +@router.post("/config/{plugin_id}/reset") +async def reset_plugin_config( + plugin_id: str, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None) +) -> Dict[str, Any]: + """ + 重置插件配置为默认值 + + 删除当前配置文件，下次加载插件时将使用默认配置。 + """ + # Token 验证 + token = get_token_from_cookie_or_header(maibot_session, authorization) + token_manager = get_token_manager() + if not token or not token_manager.verify_token(token): + raise HTTPException(status_code=401, detail="未授权：无效的访问令牌") + + logger.info(f"重置插件配置: {plugin_id}") + + try: + # 查找插件目录 + plugins_dir = Path("plugins") + plugin_path = None + + for p in plugins_dir.iterdir(): + if p.is_dir(): + manifest_path = p / "_manifest.json" + if manifest_path.exists(): + try: + with open(manifest_path, "r", encoding="utf-8") as f: + manifest = json.load(f) + if manifest.get("id") == plugin_id or p.name == plugin_id: + plugin_path = p + break + except Exception: + continue + + if not plugin_path: + raise HTTPException(status_code=404, detail=f"未找到插件: {plugin_id}") + + config_path = plugin_path / "config.toml" + + if not config_path.exists(): + return {"success": True, "message": "配置文件不存在，无需重置"} + + # 备份并删除 + import shutil + import datetime + + backup_name = f"config.toml.reset.{datetime.datetime.now().strftime('%Y%m%d%H%M%S')}" + backup_path = plugin_path / backup_name + shutil.move(config_path, backup_path) + + logger.info(f"已重置插件配置: {plugin_id}，备份: {backup_path}") + + return {"success": True, "message": "配置已重置，下次加载插件时将使用默认配置", "backup": str(backup_path)} + + except HTTPException: + raise + except Exception as e: + logger.error(f"重置插件配置失败: {e}", exc_info=True) + raise HTTPException(status_code=500, detail=f"服务器错误: {str(e)}") from e + + +@router.post("/config/{plugin_id}/toggle") +async def toggle_plugin( + plugin_id: str, maibot_session: Optional[str] = Cookie(None), authorization: Optional[str] = Header(None) +) -> Dict[str, Any]: + """ + 切换插件启用状态 + + 切换插件配置中的 enabled 字段。 + """ + # Token 验证 + token = get_token_from_cookie_or_header(maibot_session, authorization) + token_manager = get_token_manager() + if not token or not token_manager.verify_token(token): + raise HTTPException(status_code=401, detail="未授权：无效的访问令牌") + + logger.info(f"切换插件状态: {plugin_id}") + + try: + # 查找插件目录 + plugins_dir = Path("plugins") + plugin_path = None + + for p in plugins_dir.iterdir(): + if p.is_dir(): + manifest_path = p / "_manifest.json" + if manifest_path.exists(): + try: + with open(manifest_path, "r", encoding="utf-8") as f: + manifest = json.load(f) + if manifest.get("id") == plugin_id or p.name == plugin_id: + plugin_path = p + break + except Exception: + continue + + if not plugin_path: + raise HTTPException(status_code=404, detail=f"未找到插件: {plugin_id}") + + config_path = plugin_path / "config.toml" + + import tomlkit + + # 读取当前配置（保留注释和格式） + config = tomlkit.document() + if config_path.exists(): + with open(config_path, "r", encoding="utf-8") as f: + config = tomlkit.load(f) + + # 切换 enabled 状态 + if "plugin" not in config: + config["plugin"] = tomlkit.table() + + current_enabled = config["plugin"].get("enabled", True) + new_enabled = not current_enabled + config["plugin"]["enabled"] = new_enabled + + # 写入配置（保留注释，格式化数组） + save_toml_with_format(config, str(config_path)) + + status = "启用" if new_enabled else "禁用" + logger.info(f"已{status}插件: {plugin_id}") + + return { + "success": True, + "enabled": new_enabled, + "message": f"插件已{status}", + "note": "状态更改将在下次加载插件时生效", + } + + except HTTPException: + raise + except Exception as e: + logger.error(f"切换插件状态失败: {e}", exc_info=True) + raise HTTPException(status_code=500, detail=f"服务器错误: {str(e)}") from e diff --git a/src/webui/rate_limiter.py b/src/webui/rate_limiter.py new file mode 100644 index 00000000..23cfc0f0 --- /dev/null +++ b/src/webui/rate_limiter.py @@ -0,0 +1,245 @@ +""" +WebUI 请求频率限制模块 +防止暴力破解和 API 滥用 +""" + +import time +from collections import defaultdict +from typing import Dict, Tuple, Optional +from fastapi import Request, HTTPException +from src.common.logger import get_logger + +logger = get_logger("webui.rate_limiter") + + +class RateLimiter: + """ + 简单的内存请求频率限制器 + + 使用滑动窗口算法实现 + """ + + def __init__(self): + # 存储格式: {key: [(timestamp, count), ...]} + self._requests: Dict[str, list] = defaultdict(list) + # 被封禁的 IP: {ip: unblock_timestamp} + self._blocked: Dict[str, float] = {} + + def _get_client_ip(self, request: Request) -> str: + """获取客户端 IP 地址""" + # 检查代理头 + forwarded = request.headers.get("X-Forwarded-For") + if forwarded: + # 取第一个 IP（最原始的客户端） + return forwarded.split(",")[0].strip() + + real_ip = request.headers.get("X-Real-IP") + if real_ip: + return real_ip + + # 直接连接的客户端 + if request.client: + return request.client.host + + return "unknown" + + def _cleanup_old_requests(self, key: str, window_seconds: int): + """清理过期的请求记录""" + now = time.time() + cutoff = now - window_seconds + self._requests[key] = [(ts, count) for ts, count in self._requests[key] if ts > cutoff] + + def _cleanup_expired_blocks(self): + """清理过期的封禁""" + now = time.time() + expired = [ip for ip, unblock_time in self._blocked.items() if now > unblock_time] + for ip in expired: + del self._blocked[ip] + logger.info(f"🔓 IP {ip} 封禁已解除") + + def is_blocked(self, request: Request) -> Tuple[bool, Optional[int]]: + """ + 检查 IP 是否被封禁 + + Returns: + (是否被封禁, 剩余封禁秒数) + """ + self._cleanup_expired_blocks() + ip = self._get_client_ip(request) + + if ip in self._blocked: + remaining = int(self._blocked[ip] - time.time()) + return True, max(0, remaining) + + return False, None + + def check_rate_limit( + self, request: Request, max_requests: int, window_seconds: int, key_suffix: str = "" + ) -> Tuple[bool, int]: + """ + 检查请求是否超过频率限制 + + Args: + request: FastAPI Request 对象 + max_requests: 窗口期内允许的最大请求数 + window_seconds: 窗口时间（秒） + key_suffix: 键后缀，用于区分不同的限制规则 + + Returns: + (是否允许, 剩余请求数) + """ + ip = self._get_client_ip(request) + key = f"{ip}:{key_suffix}" if key_suffix else ip + + # 清理过期记录 + self._cleanup_old_requests(key, window_seconds) + + # 计算当前窗口内的请求数 + current_count = sum(count for _, count in self._requests[key]) + + if current_count >= max_requests: + return False, 0 + + # 记录新请求 + now = time.time() + self._requests[key].append((now, 1)) + + remaining = max_requests - current_count - 1 + return True, remaining + + def block_ip(self, request: Request, duration_seconds: int): + """ + 封禁 IP + + Args: + request: FastAPI Request 对象 + duration_seconds: 封禁时长（秒） + """ + ip = self._get_client_ip(request) + self._blocked[ip] = time.time() + duration_seconds + logger.warning(f"🔒 IP {ip} 已被封禁 {duration_seconds} 秒") + + def record_failed_attempt( + self, request: Request, max_failures: int = 5, window_seconds: int = 300, block_duration: int = 600 + ) -> Tuple[bool, int]: + """ + 记录失败尝试（如登录失败） + + 如果在窗口期内失败次数过多，自动封禁 IP + + Args: + request: FastAPI Request 对象 + max_failures: 允许的最大失败次数 + window_seconds: 统计窗口（秒） + block_duration: 封禁时长（秒） + + Returns: + (是否被封禁, 剩余尝试次数) + """ + ip = self._get_client_ip(request) + key = f"{ip}:auth_failures" + + # 清理过期记录 + self._cleanup_old_requests(key, window_seconds) + + # 计算当前失败次数 + current_failures = sum(count for _, count in self._requests[key]) + + # 记录本次失败 + now = time.time() + self._requests[key].append((now, 1)) + current_failures += 1 + + remaining = max_failures - current_failures + + # 检查是否需要封禁 + if current_failures >= max_failures: + self.block_ip(request, block_duration) + logger.warning(f"⚠️ IP {ip} 认证失败次数过多 ({current_failures}/{max_failures})，已封禁") + return True, 0 + + if current_failures >= max_failures - 2: + logger.warning(f"⚠️ IP {ip} 认证失败 {current_failures}/{max_failures} 次") + + return False, max(0, remaining) + + def reset_failures(self, request: Request): + """ + 重置失败计数（认证成功后调用） + """ + ip = self._get_client_ip(request) + key = f"{ip}:auth_failures" + if key in self._requests: + del self._requests[key] + + +# 全局单例 +_rate_limiter: Optional[RateLimiter] = None + + +def get_rate_limiter() -> RateLimiter: + """获取 RateLimiter 单例""" + global _rate_limiter + if _rate_limiter is None: + _rate_limiter = RateLimiter() + return _rate_limiter + + +async def check_auth_rate_limit(request: Request): + """ + 认证接口的频率限制依赖 + + 规则： + - 每个 IP 每分钟最多 10 次认证请求 + - 连续失败 5 次后封禁 10 分钟 + """ + limiter = get_rate_limiter() + + # 检查是否被封禁 + blocked, remaining_block = limiter.is_blocked(request) + if blocked: + raise HTTPException( + status_code=429, + detail=f"请求过于频繁，请在 {remaining_block} 秒后重试", + headers={"Retry-After": str(remaining_block)}, + ) + + # 检查频率限制 + allowed, remaining = limiter.check_rate_limit( + request, + max_requests=10, # 每分钟 10 次 + window_seconds=60, + key_suffix="auth", + ) + + if not allowed: + raise HTTPException(status_code=429, detail="认证请求过于频繁，请稍后重试", headers={"Retry-After": "60"}) + + +async def check_api_rate_limit(request: Request): + """ + 普通 API 的频率限制依赖 + + 规则：每个 IP 每分钟最多 100 次请求 + """ + limiter = get_rate_limiter() + + # 检查是否被封禁 + blocked, remaining_block = limiter.is_blocked(request) + if blocked: + raise HTTPException( + status_code=429, + detail=f"请求过于频繁，请在 {remaining_block} 秒后重试", + headers={"Retry-After": str(remaining_block)}, + ) + + # 检查频率限制 + allowed, _ = limiter.check_rate_limit( + request, + max_requests=100, # 每分钟 100 次 + window_seconds=60, + key_suffix="api", + ) + + if not allowed: + raise HTTPException(status_code=429, detail="请求过于频繁，请稍后重试", headers={"Retry-After": "60"}) diff --git a/src/webui/routers/system.py b/src/webui/routers/system.py index fb203f79..b1d3729a 100644 --- a/src/webui/routers/system.py +++ b/src/webui/routers/system.py @@ -5,19 +5,30 @@ """ import os -import sys import time from datetime import datetime -from fastapi import APIRouter, HTTPException +from typing import Optional +from fastapi import APIRouter, HTTPException, Depends, Cookie, Header from pydantic import BaseModel from src.config.config import MMC_VERSION +from src.common.logger import get_logger +from src.webui.auth import verify_auth_token_from_cookie_or_header router = APIRouter(prefix="/system", tags=["system"]) +logger = get_logger("webui_system") # 记录启动时间 _start_time = time.time() +def require_auth( + maibot_session: Optional[str] = Cookie(None), + authorization: Optional[str] = Header(None), +) -> bool: + """认证依赖：验证用户是否已登录""" + return verify_auth_token_from_cookie_or_header(maibot_session, authorization) + + class RestartResponse(BaseModel): """重启响应""" @@ -35,33 +46,38 @@ class StatusResponse(BaseModel): @router.post("/restart", response_model=RestartResponse) -async def restart_maibot(): +async def restart_maibot(_auth: bool = Depends(require_auth)): """ 重启麦麦主程序 - 使用 os.execv 重启当前进程，配置更改将在重启后生效。 + 请求重启当前进程，配置更改将在重启后生效。 注意：此操作会使麦麦暂时离线。 """ + import asyncio + try: # 记录重启操作 - print(f"[{datetime.now()}] WebUI 触发重启操作") + logger.info("WebUI 触发重启操作") - # 使用 os.execv 重启当前进程 - # 这会替换当前进程，保持相同的 PID - python = sys.executable - args = [python] + sys.argv + # 定义延迟重启的异步任务 + async def delayed_restart(): + await asyncio.sleep(0.5) # 延迟0.5秒，确保响应已发送 + # 使用 os._exit(42) 退出当前进程，配合外部 runner 脚本进行重启 + # 42 是约定的重启状态码 + logger.info("WebUI 请求重启，退出代码 42") + os._exit(42) - # 返回成功响应（实际上这个响应可能不会发送，因为进程会立即重启） - # 但我们仍然返回它以保持 API 一致性 - os.execv(python, args) + # 创建后台任务执行重启 + asyncio.create_task(delayed_restart()) + # 立即返回成功响应 return RestartResponse(success=True, message="麦麦正在重启中...") except Exception as e: raise HTTPException(status_code=500, detail=f"重启失败: {str(e)}") from e @router.get("/status", response_model=StatusResponse) -async def get_maibot_status(): +async def get_maibot_status(_auth: bool = Depends(require_auth)): """ 获取麦麦运行状态 @@ -84,7 +100,7 @@ async def get_maibot_status(): @router.post("/reload-config") -async def reload_config(): +async def reload_config(_auth: bool = Depends(require_auth)): """ 热重载配置（不重启进程） diff --git a/src/webui/routes.py b/src/webui/routes.py index 3eb7e673..8f85490c 100644 --- a/src/webui/routes.py +++ b/src/webui/routes.py @@ -1,18 +1,23 @@ """WebUI API 路由""" -from fastapi import APIRouter, HTTPException, Header +from fastapi import APIRouter, HTTPException, Header, Response, Request, Cookie, Depends from pydantic import BaseModel, Field from typing import Optional from src.common.logger import get_logger from .token_manager import get_token_manager +from .auth import set_auth_cookie, clear_auth_cookie +from .rate_limiter import get_rate_limiter, check_auth_rate_limit from .config_routes import router as config_router from .statistics_routes import router as statistics_router from .person_routes import router as person_router from .expression_routes import router as expression_router +from .jargon_routes import router as jargon_router from .emoji_routes import router as emoji_router from .plugin_routes import router as plugin_router from .plugin_progress_ws import get_progress_router from .routers.system import router as system_router +from .model_routes import router as model_router +from .ws_auth import router as ws_auth_router logger = get_logger("webui.api") @@ -27,6 +32,8 @@ router.include_router(statistics_router) router.include_router(person_router) # 注册表达方式管理路由 router.include_router(expression_router) +# 注册黑话管理路由 +router.include_router(jargon_router) # 注册表情包管理路由 router.include_router(emoji_router) # 注册插件管理路由 @@ -35,6 +42,10 @@ router.include_router(plugin_router) router.include_router(get_progress_router()) # 注册系统控制路由 router.include_router(system_router) +# 注册模型列表获取路由 +router.include_router(model_router) +# 注册 WebSocket 认证路由 +router.include_router(ws_auth_router) class TokenVerifyRequest(BaseModel): @@ -48,6 +59,7 @@ class TokenVerifyResponse(BaseModel): valid: bool = Field(..., description="Token 是否有效") message: str = Field(..., description="验证结果消息") + is_first_setup: bool = Field(False, description="是否为首次设置") class TokenUpdateRequest(BaseModel): @@ -99,47 +111,151 @@ async def health_check(): @router.post("/auth/verify", response_model=TokenVerifyResponse) -async def verify_token(request: TokenVerifyRequest): +async def verify_token( + request_body: TokenVerifyRequest, + request: Request, + response: Response, + _rate_limit: None = Depends(check_auth_rate_limit), +): """ - 验证访问令牌 + 验证访问令牌，验证成功后设置 HttpOnly Cookie Args: - request: 包含 token 的验证请求 + request_body: 包含 token 的验证请求 + request: FastAPI Request 对象（用于获取客户端 IP） + response: FastAPI Response 对象 Returns: - 验证结果 + 验证结果（包含首次配置状态） """ try: token_manager = get_token_manager() - is_valid = token_manager.verify_token(request.token) + rate_limiter = get_rate_limiter() + + is_valid = token_manager.verify_token(request_body.token) if is_valid: - return TokenVerifyResponse(valid=True, message="Token 验证成功") + # 认证成功，重置失败计数 + rate_limiter.reset_failures(request) + # 设置 HttpOnly Cookie（传入 request 以检测协议） + set_auth_cookie(response, request_body.token, request) + # 同时返回首次配置状态，避免额外请求 + is_first_setup = token_manager.is_first_setup() + return TokenVerifyResponse(valid=True, message="Token 验证成功", is_first_setup=is_first_setup) else: - return TokenVerifyResponse(valid=False, message="Token 无效或已过期") + # 记录失败尝试 + blocked, remaining = rate_limiter.record_failed_attempt( + request, + max_failures=5, # 5 次失败 + window_seconds=300, # 5 分钟窗口 + block_duration=600, # 封禁 10 分钟 + ) + + if blocked: + raise HTTPException(status_code=429, detail="认证失败次数过多，您的 IP 已被临时封禁 10 分钟") + + message = "Token 无效或已过期" + if remaining <= 2: + message += f"（剩余 {remaining} 次尝试机会）" + + return TokenVerifyResponse(valid=False, message=message) + except HTTPException: + raise except Exception as e: logger.error(f"Token 验证失败: {e}") raise HTTPException(status_code=500, detail="Token 验证失败") from e +@router.post("/auth/logout") +async def logout(response: Response): + """ + 登出并清除认证 Cookie + + Args: + response: FastAPI Response 对象 + + Returns: + 登出结果 + """ + clear_auth_cookie(response) + return {"success": True, "message": "已成功登出"} + + +@router.get("/auth/check") +async def check_auth_status( + request: Request, + maibot_session: Optional[str] = Cookie(None), + authorization: Optional[str] = Header(None), +): + """ + 检查当前认证状态（用于前端判断是否已登录） + + Returns: + 认证状态 + """ + try: + token = None + + # 记录请求信息用于调试 + logger.debug(f"检查认证状态 - Cookie: {maibot_session[:20] if maibot_session else 'None'}..., Authorization: {'Present' if authorization else 'None'}") + + # 优先从 Cookie 获取 + if maibot_session: + token = maibot_session + logger.debug("使用 Cookie 中的 token") + # 其次从 Header 获取 + elif authorization and authorization.startswith("Bearer "): + token = authorization.replace("Bearer ", "") + logger.debug("使用 Header 中的 token") + + if not token: + logger.debug("未找到 token，返回未认证") + return {"authenticated": False} + + token_manager = get_token_manager() + is_valid = token_manager.verify_token(token) + logger.debug(f"Token 验证结果: {is_valid}") + + if is_valid: + return {"authenticated": True} + else: + return {"authenticated": False} + except Exception as e: + logger.error(f"认证检查失败: {e}", exc_info=True) + return {"authenticated": False} + + @router.post("/auth/update", response_model=TokenUpdateResponse) -async def update_token(request: TokenUpdateRequest, authorization: Optional[str] = Header(None)): +async def update_token( + request: TokenUpdateRequest, + response: Response, + req: Request, + maibot_session: Optional[str] = Cookie(None), + authorization: Optional[str] = Header(None), +): """ 更新访问令牌（需要当前有效的 token） Args: request: 包含新 token 的更新请求 + response: FastAPI Response 对象 + maibot_session: Cookie 中的 token authorization: Authorization header (Bearer token) Returns: 更新结果 """ try: - # 验证当前 token - if not authorization or not authorization.startswith("Bearer "): + # 验证当前 token（优先 Cookie，其次 Header） + current_token = None + if maibot_session: + current_token = maibot_session + elif authorization and authorization.startswith("Bearer "): + current_token = authorization.replace("Bearer ", "") + + if not current_token: raise HTTPException(status_code=401, detail="未提供有效的认证信息") - current_token = authorization.replace("Bearer ", "") token_manager = get_token_manager() if not token_manager.verify_token(current_token): @@ -148,6 +264,10 @@ async def update_token(request: TokenUpdateRequest, authorization: Optional[str] # 更新 token success, message = token_manager.update_token(request.new_token) + # 如果更新成功，清除 Cookie，要求用户重新登录 + if success: + clear_auth_cookie(response) + return TokenUpdateResponse(success=success, message=message) except HTTPException: raise @@ -157,22 +277,34 @@ async def update_token(request: TokenUpdateRequest, authorization: Optional[str] @router.post("/auth/regenerate", response_model=TokenRegenerateResponse) -async def regenerate_token(authorization: Optional[str] = Header(None)): +async def regenerate_token( + response: Response, + request: Request, + maibot_session: Optional[str] = Cookie(None), + authorization: Optional[str] = Header(None), +): """ 重新生成访问令牌（需要当前有效的 token） Args: + response: FastAPI Response 对象 + maibot_session: Cookie 中的 token authorization: Authorization header (Bearer token) Returns: 新生成的 token """ try: - # 验证当前 token - if not authorization or not authorization.startswith("Bearer "): + # 验证当前 token（优先 Cookie，其次 Header） + current_token = None + if maibot_session: + current_token = maibot_session + elif authorization and authorization.startswith("Bearer "): + current_token = authorization.replace("Bearer ", "") + + if not current_token: raise HTTPException(status_code=401, detail="未提供有效的认证信息") - current_token = authorization.replace("Bearer ", "") token_manager = get_token_manager() if not token_manager.verify_token(current_token): @@ -181,6 +313,9 @@ async def regenerate_token(authorization: Optional[str] = Header(None)): # 重新生成 token new_token = token_manager.regenerate_token() + # 清除 Cookie，要求用户重新登录 + clear_auth_cookie(response) + return TokenRegenerateResponse(success=True, token=new_token, message="Token 已重新生成") except HTTPException: raise @@ -190,22 +325,32 @@ async def regenerate_token(authorization: Optional[str] = Header(None)): @router.get("/setup/status", response_model=FirstSetupStatusResponse) -async def get_setup_status(authorization: Optional[str] = Header(None)): +async def get_setup_status( + request: Request, + maibot_session: Optional[str] = Cookie(None), + authorization: Optional[str] = Header(None), +): """ 获取首次配置状态 Args: + maibot_session: Cookie 中的 token authorization: Authorization header (Bearer token) Returns: 首次配置状态 """ try: - # 验证 token - if not authorization or not authorization.startswith("Bearer "): + # 验证 token（优先 Cookie，其次 Header） + current_token = None + if maibot_session: + current_token = maibot_session + elif authorization and authorization.startswith("Bearer "): + current_token = authorization.replace("Bearer ", "") + + if not current_token: raise HTTPException(status_code=401, detail="未提供有效的认证信息") - current_token = authorization.replace("Bearer ", "") token_manager = get_token_manager() if not token_manager.verify_token(current_token): @@ -223,22 +368,32 @@ async def get_setup_status(authorization: Optional[str] = Header(None)): @router.post("/setup/complete", response_model=CompleteSetupResponse) -async def complete_setup(authorization: Optional[str] = Header(None)): +async def complete_setup( + request: Request, + maibot_session: Optional[str] = Cookie(None), + authorization: Optional[str] = Header(None), +): """ 标记首次配置完成 Args: + maibot_session: Cookie 中的 token authorization: Authorization header (Bearer token) Returns: 完成结果 """ try: - # 验证 token - if not authorization or not authorization.startswith("Bearer "): + # 验证 token（优先 Cookie，其次 Header） + current_token = None + if maibot_session: + current_token = maibot_session + elif authorization and authorization.startswith("Bearer "): + current_token = authorization.replace("Bearer ", "") + + if not current_token: raise HTTPException(status_code=401, detail="未提供有效的认证信息") - current_token = authorization.replace("Bearer ", "") token_manager = get_token_manager() if not token_manager.verify_token(current_token): @@ -256,22 +411,32 @@ async def complete_setup(authorization: Optional[str] = Header(None)): @router.post("/setup/reset", response_model=ResetSetupResponse) -async def reset_setup(authorization: Optional[str] = Header(None)): +async def reset_setup( + request: Request, + maibot_session: Optional[str] = Cookie(None), + authorization: Optional[str] = Header(None), +): """ 重置首次配置状态，允许重新进入配置向导 Args: + maibot_session: Cookie 中的 token authorization: Authorization header (Bearer token) Returns: 重置结果 """ try: - # 验证 token - if not authorization or not authorization.startswith("Bearer "): + # 验证 token（优先 Cookie，其次 Header） + current_token = None + if maibot_session: + current_token = maibot_session + elif authorization and authorization.startswith("Bearer "): + current_token = authorization.replace("Bearer ", "") + + if not current_token: raise HTTPException(status_code=401, detail="未提供有效的认证信息") - current_token = authorization.replace("Bearer ", "") token_manager = get_token_manager() if not token_manager.verify_token(current_token): diff --git a/src/webui/statistics_routes.py b/src/webui/statistics_routes.py index b0a3664c..e5628538 100644 --- a/src/webui/statistics_routes.py +++ b/src/webui/statistics_routes.py @@ -1,19 +1,28 @@ """统计数据 API 路由""" -from fastapi import APIRouter, HTTPException +from fastapi import APIRouter, HTTPException, Depends, Cookie, Header from pydantic import BaseModel, Field -from typing import Dict, Any, List +from typing import Dict, Any, List, Optional from datetime import datetime, timedelta from peewee import fn from src.common.logger import get_logger from src.common.database.database_model import LLMUsage, OnlineTime, Messages +from src.webui.auth import verify_auth_token_from_cookie_or_header logger = get_logger("webui.statistics") router = APIRouter(prefix="/statistics", tags=["statistics"]) +def require_auth( + maibot_session: Optional[str] = Cookie(None), + authorization: Optional[str] = Header(None), +) -> bool: + """认证依赖：验证用户是否已登录""" + return verify_auth_token_from_cookie_or_header(maibot_session, authorization) + + class StatisticsSummary(BaseModel): """统计数据摘要""" @@ -58,7 +67,7 @@ class DashboardData(BaseModel): @router.get("/dashboard", response_model=DashboardData) -async def get_dashboard_data(hours: int = 24): +async def get_dashboard_data(hours: int = 24, _auth: bool = Depends(require_auth)): """ 获取仪表盘统计数据 @@ -275,7 +284,7 @@ async def _get_recent_activity(limit: int = 10) -> List[Dict[str, Any]]: @router.get("/summary") -async def get_summary(hours: int = 24): +async def get_summary(hours: int = 24, _auth: bool = Depends(require_auth)): """ 获取统计摘要 @@ -293,7 +302,7 @@ async def get_summary(hours: int = 24): @router.get("/models") -async def get_model_stats(hours: int = 24): +async def get_model_stats(hours: int = 24, _auth: bool = Depends(require_auth)): """ 获取模型统计 diff --git a/src/webui/token_manager.py b/src/webui/token_manager.py index 69abf1d8..bd1e5fbb 100644 --- a/src/webui/token_manager.py +++ b/src/webui/token_manager.py @@ -160,13 +160,29 @@ class TokenManager: def regenerate_token(self) -> str: """ - 重新生成 token + 重新生成 token（保留 first_setup_completed 状态） Returns: str: 新生成的 token """ logger.info("正在重新生成 WebUI Token...") - return self._create_new_token() + + # 生成新的 64 位十六进制字符串 + new_token = secrets.token_hex(32) + + # 加载现有配置，保留 first_setup_completed 状态 + config = self._load_config() + old_token = config.get("access_token", "")[:8] if config.get("access_token") else "无" + first_setup_completed = config.get("first_setup_completed", True) # 默认为 True，表示已完成配置 + + config["access_token"] = new_token + config["updated_at"] = self._get_current_timestamp() + config["first_setup_completed"] = first_setup_completed # 保留原来的状态 + + self._save_config(config) + logger.info(f"WebUI Token 已重新生成: {old_token}... -> {new_token[:8]}...") + + return new_token def _validate_token_format(self, token: str) -> bool: """ diff --git a/src/webui/webui_server.py b/src/webui/webui_server.py index 61d279e2..da5732d0 100644 --- a/src/webui/webui_server.py +++ b/src/webui/webui_server.py @@ -1,10 +1,10 @@ -"""独立的 WebUI 服务器 - 运行在 0.0.0.0:8001""" +"""独立的 WebUI 服务器 - 默认运行在 127.0.0.1:8001""" -import os import asyncio import mimetypes from pathlib import Path from fastapi import FastAPI +from fastapi.middleware.cors import CORSMiddleware from fastapi.responses import FileResponse from uvicorn import Config, Server as UvicornServer from src.common.logger import get_logger @@ -15,24 +15,59 @@ logger = get_logger("webui_server") class WebUIServer: """独立的 WebUI 服务器""" - def __init__(self, host: str = "0.0.0.0", port: int = 8001): + def __init__(self, host: str = "127.0.0.1", port: int = 8001): self.host = host self.port = port self.app = FastAPI(title="MaiBot WebUI") self._server = None - + + # 配置防爬虫中间件（需要在CORS之前注册） + self._setup_anti_crawler() + + # 配置 CORS（支持开发环境跨域请求） + self._setup_cors() + # 显示 Access Token self._show_access_token() - + # 重要：先注册 API 路由，再设置静态文件 self._register_api_routes() self._setup_static_files() + # 注册robots.txt路由 + self._setup_robots_txt() + + def _setup_cors(self): + """配置 CORS 中间件""" + # 开发环境需要允许前端开发服务器的跨域请求 + self.app.add_middleware( + CORSMiddleware, + allow_origins=[ + "http://localhost:5173", # Vite 开发服务器 + "http://127.0.0.1:5173", + "http://localhost:7999", # 前端开发服务器备用端口 + "http://127.0.0.1:7999", + "http://localhost:8001", # 生产环境 + "http://127.0.0.1:8001", + ], + allow_credentials=True, # 允许携带 Cookie + allow_methods=["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"], # 明确指定允许的方法 + allow_headers=[ + "Content-Type", + "Authorization", + "Accept", + "Origin", + "X-Requested-With", + ], # 明确指定允许的头 + expose_headers=["Content-Length", "Content-Type"], # 允许前端读取的响应头 + ) + logger.debug("✅ CORS 中间件已配置") + def _show_access_token(self): """显示 WebUI Access Token""" try: from src.webui.token_manager import get_token_manager - + token_manager = get_token_manager() current_token = token_manager.get_token() logger.info(f"🔑 WebUI Access Token: {current_token}") @@ -68,37 +103,94 @@ class WebUIServer: """服务单页应用 - 只处理非 API 请求""" # 如果是根路径，直接返回 index.html if not full_path or full_path == "/": - return FileResponse(static_path / "index.html", media_type="text/html") - + response = FileResponse(static_path / "index.html", media_type="text/html") + response.headers["X-Robots-Tag"] = "noindex, nofollow, noarchive" + return response + # 检查是否是静态文件 file_path = static_path / full_path if file_path.is_file() and file_path.exists(): # 自动检测 MIME 类型 media_type = mimetypes.guess_type(str(file_path))[0] - return FileResponse(file_path, media_type=media_type) + response = FileResponse(file_path, media_type=media_type) + # HTML 文件添加防索引头 + if str(file_path).endswith(".html"): + response.headers["X-Robots-Tag"] = "noindex, nofollow, noarchive" + return response # 其他路径返回 index.html（SPA 路由） - return FileResponse(static_path / "index.html", media_type="text/html") + response = FileResponse(static_path / "index.html", media_type="text/html") + response.headers["X-Robots-Tag"] = "noindex, nofollow, noarchive" + return response logger.info(f"✅ WebUI 静态文件服务已配置: {static_path}") + def _setup_anti_crawler(self): + """配置防爬虫中间件""" + try: + from src.webui.anti_crawler import AntiCrawlerMiddleware + from src.config.config import global_config + + # 从配置读取防爬虫模式 + anti_crawler_mode = global_config.webui.anti_crawler_mode + + # 注意：中间件按注册顺序反向执行，所以先注册的中间件后执行 + # 我们需要在CORS之前注册，这样防爬虫检查会在CORS之前执行 + self.app.add_middleware(AntiCrawlerMiddleware, mode=anti_crawler_mode) + + mode_descriptions = {"false": "已禁用", "strict": "严格模式", "loose": "宽松模式", "basic": "基础模式"} + mode_desc = mode_descriptions.get(anti_crawler_mode, "基础模式") + logger.info(f"🛡️ 防爬虫中间件已配置: {mode_desc}") + except Exception as e: + logger.error(f"❌ 配置防爬虫中间件失败: {e}", exc_info=True) + + def _setup_robots_txt(self): + """设置robots.txt路由""" + try: + from src.webui.anti_crawler import create_robots_txt_response + + @self.app.get("/robots.txt", include_in_schema=False) + async def robots_txt(): + """返回robots.txt，禁止所有爬虫""" + return create_robots_txt_response() + + logger.debug("✅ robots.txt 路由已注册") + except Exception as e: + logger.error(f"❌ 注册robots.txt路由失败: {e}", exc_info=True) + def _register_api_routes(self): """注册所有 WebUI API 路由""" try: # 导入所有 WebUI 路由 from src.webui.routes import router as webui_router from src.webui.logs_ws import router as logs_router + from src.webui.knowledge_routes import router as knowledge_router + + # 导入本地聊天室路由 + from src.webui.chat_routes import router as chat_router # 注册路由 self.app.include_router(webui_router) self.app.include_router(logs_router) + self.app.include_router(knowledge_router) + self.app.include_router(chat_router) logger.info("✅ WebUI API 路由已注册") except Exception as e: - logger.error(f"❌ 注册 WebUI API 路由失败: {e}") + logger.error(f"❌ 注册 WebUI API 路由失败: {e}", exc_info=True) async def start(self): """启动服务器""" + # 预先检查端口是否可用 + if not self._check_port_available(): + error_msg = f"❌ WebUI 服务器启动失败: 端口 {self.port} 已被占用" + logger.error(error_msg) + logger.error(f"💡 请检查是否有其他程序正在使用端口 {self.port}") + logger.error("💡 可以在 .env 文件中修改 WEBUI_PORT 来更改 WebUI 端口") + logger.error(f"💡 Windows 用户可以运行: netstat -ano | findstr :{self.port}") + logger.error(f"💡 Linux/Mac 用户可以运行: lsof -i :{self.port}") + raise OSError(f"端口 {self.port} 已被占用，无法启动 WebUI 服务器") + config = Config( app=self.app, host=self.host, @@ -109,13 +201,59 @@ class WebUIServer: self._server = UvicornServer(config=config) logger.info("🌐 WebUI 服务器启动中...") - logger.info(f"🌐 访问地址: http://{self.host}:{self.port}") + + # 根据地址类型显示正确的访问地址 + if ':' in self.host: + # IPv6 地址需要用方括号包裹 + logger.info(f"🌐 访问地址: http://[{self.host}]:{self.port}") + if self.host == "::": + logger.info(f"💡 IPv6 本机访问: http://[::1]:{self.port}") + logger.info(f"💡 IPv4 本机访问: http://127.0.0.1:{self.port}") + elif self.host == "::1": + logger.info("💡 仅支持 IPv6 本地访问") + else: + # IPv4 地址 + logger.info(f"🌐 访问地址: http://{self.host}:{self.port}") + if self.host == "0.0.0.0": + logger.info(f"💡 本机访问: http://localhost:{self.port} 或 http://127.0.0.1:{self.port}") try: await self._server.serve() - except Exception as e: - logger.error(f"❌ WebUI 服务器运行错误: {e}") + except OSError as e: + # 处理端口绑定相关的错误 + if "address already in use" in str(e).lower() or e.errno in (98, 10048): # 98: Linux, 10048: Windows + logger.error(f"❌ WebUI 服务器启动失败: 端口 {self.port} 已被占用") + logger.error(f"💡 请检查是否有其他程序正在使用端口 {self.port}") + logger.error("💡 可以在 .env 文件中修改 WEBUI_PORT 来更改 WebUI 端口") + else: + logger.error(f"❌ WebUI 服务器启动失败 (网络错误): {e}") raise + except Exception as e: + logger.error(f"❌ WebUI 服务器运行错误: {e}", exc_info=True) + raise + + def _check_port_available(self) -> bool: + """检查端口是否可用（支持 IPv4 和 IPv6）""" + import socket + + # 判断使用 IPv4 还是 IPv6 + if ':' in self.host: + # IPv6 地址 + family = socket.AF_INET6 + test_host = self.host if self.host != "::" else "::1" + else: + # IPv4 地址 + family = socket.AF_INET + test_host = self.host if self.host != "0.0.0.0" else "127.0.0.1" + + try: + with socket.socket(family, socket.SOCK_STREAM) as s: + s.settimeout(1) + # 尝试绑定端口 + s.bind((test_host, self.port)) + return True + except OSError: + return False async def shutdown(self): """关闭服务器""" @@ -141,8 +279,9 @@ def get_webui_server() -> WebUIServer: """获取全局 WebUI 服务器实例""" global _webui_server if _webui_server is None: - # 从环境变量读取配置 - host = os.getenv("WEBUI_HOST", "0.0.0.0") + # 从环境变量读取 + import os + host = os.getenv("WEBUI_HOST", "127.0.0.1") port = int(os.getenv("WEBUI_PORT", "8001")) _webui_server = WebUIServer(host=host, port=port) return _webui_server diff --git a/src/webui/ws_auth.py b/src/webui/ws_auth.py new file mode 100644 index 00000000..e6bb00e7 --- /dev/null +++ b/src/webui/ws_auth.py @@ -0,0 +1,114 @@ +"""WebSocket 认证模块 + +提供所有 WebSocket 端点统一使用的临时 token 认证机制。 +临时 token 有效期 60 秒，且只能使用一次，用于解决 WebSocket 握手时 Cookie 不可用的问题。 +""" + +from fastapi import APIRouter, Cookie, Header +from typing import Optional +import secrets +import time +from src.common.logger import get_logger +from src.webui.token_manager import get_token_manager + +logger = get_logger("webui.ws_auth") +router = APIRouter() + +# WebSocket 临时 token 存储 {token: (expire_time, session_token)} +# 临时 token 有效期 60 秒，仅用于 WebSocket 握手 +_ws_temp_tokens: dict[str, tuple[float, str]] = {} +_WS_TOKEN_EXPIRE_SECONDS = 60 + + +def _cleanup_expired_ws_tokens(): + """清理过期的临时 token""" + now = time.time() + expired = [t for t, (exp, _) in _ws_temp_tokens.items() if now > exp] + for t in expired: + del _ws_temp_tokens[t] + + +def generate_ws_token(session_token: str) -> str: + """生成 WebSocket 临时 token + + Args: + session_token: 原始的 session token + + Returns: + 临时 token 字符串 + """ + _cleanup_expired_ws_tokens() + temp_token = secrets.token_urlsafe(32) + _ws_temp_tokens[temp_token] = (time.time() + _WS_TOKEN_EXPIRE_SECONDS, session_token) + logger.debug(f"生成 WS 临时 token: {temp_token[:8]}... 有效期 {_WS_TOKEN_EXPIRE_SECONDS}s") + return temp_token + + +def verify_ws_token(temp_token: str) -> bool: + """验证并消费 WebSocket 临时 token（一次性使用） + + Args: + temp_token: 临时 token + + Returns: + 验证是否通过 + """ + _cleanup_expired_ws_tokens() + if temp_token not in _ws_temp_tokens: + logger.warning(f"WS token 不存在: {temp_token[:8]}...") + return False + expire_time, session_token = _ws_temp_tokens[temp_token] + if time.time() > expire_time: + del _ws_temp_tokens[temp_token] + logger.warning(f"WS token 已过期: {temp_token[:8]}...") + return False + # 验证原始 session token 仍然有效 + token_manager = get_token_manager() + if not token_manager.verify_token(session_token): + del _ws_temp_tokens[temp_token] + logger.warning(f"WS token 关联的 session 已失效: {temp_token[:8]}...") + return False + # 消费 token（一次性使用） + del _ws_temp_tokens[temp_token] + logger.debug(f"WS token 验证成功: {temp_token[:8]}...") + return True + + +@router.get("/ws-token") +async def get_ws_token( + maibot_session: Optional[str] = Cookie(None), + authorization: Optional[str] = Header(None), +): + """ + 获取 WebSocket 连接用的临时 token + + 此端点验证当前会话的 Cookie 或 Authorization header， + 然后返回一个临时 token 用于 WebSocket 握手认证。 + 临时 token 有效期 60 秒，且只能使用一次。 + + 注意：在未认证时返回 200 状态码但 success=False，避免前端因 401 刷新页面。 + """ + # 获取当前 session token + session_token = None + if maibot_session: + session_token = maibot_session + elif authorization and authorization.startswith("Bearer "): + session_token = authorization.replace("Bearer ", "") + + if not session_token: + # 返回 200 但 success=False，避免前端因 401 刷新页面 + # 这在登录页面是正常情况，不应该触发错误处理 + logger.debug("ws-token 请求：未提供认证信息（可能在登录页面）") + return {"success": False, "message": "未提供认证信息，请先登录", "token": None, "expires_in": 0} + + # 验证 session token + token_manager = get_token_manager() + if not token_manager.verify_token(session_token): + # 同样返回 200 但 success=False，避免前端刷新 + logger.debug("ws-token 请求：认证已过期") + return {"success": False, "message": "认证已过期，请重新登录", "token": None, "expires_in": 0} + + # 生成临时 WebSocket token + ws_token = generate_ws_token(session_token) + + return {"success": True, "token": ws_token, "expires_in": _WS_TOKEN_EXPIRE_SECONDS} diff --git a/template/bot_config_template.toml b/template/bot_config_template.toml index 2c1da1be..9b0544aa 100644 --- a/template/bot_config_template.toml +++ b/template/bot_config_template.toml @@ -1,9 +1,9 @@ [inner] -version = "6.21.8" +version = "7.2.5" #----以下是给开发人员阅读的，如果你只是部署了麦麦，不需要阅读---- -#如果你想要修改配置文件，请递增version的值 -#如果新增项目，请阅读src/config/official_configs.py中的说明 +# 如果你想要修改配置文件，请递增version的值 +# 如果新增项目，请阅读src/config/official_configs.py中的说明 # # 版本格式：主版本号.次版本号.修订号，版本号递增规则如下： # 主版本号：MMC版本更新 @@ -22,21 +22,31 @@ alias_names = ["麦叠", "牢麦"] # 麦麦的别名 [personality] # 建议120字以内，描述人格特质 和 身份特征 -personality = "是一个女大学生，现在在读大二，会刷贴吧。" -#アイデンティティがない 生まれないらららら -# 描述麦麦说话的表达风格，表达习惯，如要修改，可以酌情新增内容 -reply_style = "请回复的平淡一些，简短一些，说中文，不要刻意突出自身学科背景。可以参考贴吧，知乎和微博的回复风格。" +personality = "是一个大二在读女大学生，现在正在上网和群友聊天，有时有点攻击性，有时比较温柔" +# アイデンティティがない 生まれないらららら +# 描述麦麦说话的表达风格，表达习惯，如要修改，可以酌情新增内容，建议1-2行 +reply_style = "请不要刻意突出自身学科背景。可以参考贴吧，知乎和微博的回复风格。" -# 麦麦的兴趣，会影响麦麦对什么话题进行回复 -interest = "对技术相关话题，游戏和动漫相关话题感兴趣，也对日常话题感兴趣，不喜欢太过沉重严肃的话题" +# 多种回复风格列表，可选配置：当 non-empty 且 multiple_probability>0 时，会按概率随机从中选择一个替换 reply_style +multiple_reply_style = [ + # "你的风格平淡但不失讽刺，很简短,很白话。可以参考贴吧，微博的回复风格。", + # "用1-2个字进行回复", + # "用1-2个符号进行回复", + # "言辭凝練古雅，穿插《論語》經句卻不晦澀，以文言短句為基，輔以淺白語意，持長者溫和風範，全用繁體字表達，具先秦儒者談吐韻致。", + # "带点翻译腔，但不要太长", +] + +# 替换概率：每次构建回复时，以该概率从 multiple_reply_style 中随机选择一个替换 reply_style（0.0-1.0） +multiple_probability = 0.3 # 麦麦的说话规则，行为风格: plan_style = """ 1.思考**所有**的可用的action中的**每个动作**是否符合当下条件，如果动作使用条件符合聊天内容就使用 2.如果相同的内容已经被执行，请不要重复执行 -3.请控制你的发言频率，不要太过频繁的发言 -4.如果有人对你感到厌烦，请减少回复 -5.如果有人对你进行攻击，或者情绪激动，请你以合适的方法应对""" +3.你对技术相关话题，游戏和动漫相关话题感兴趣，也对日常话题感兴趣，不喜欢太过沉重严肃的话题 +4.请控制你的发言频率，不要太过频繁的发言 +5.如果有人对你感到厌烦，请减少回复 +6.如果有人在追问你，或者话题没有说完，请你继续回复""" # 麦麦识图规则，不建议修改 visual_style = "请用中文描述这张图片的内容。如果有文字，请把文字描述概括出来，请留意其主题，直观感受，输出为一段平文本，最多30字，请注意不要分点，就输出一段文本" @@ -57,18 +67,19 @@ states = [ # 替换概率，每次构建人格时替换personality的概率（0.0-1.0） state_probability = 0.3 + + [expression] # 表达学习配置 learning_list = [ # 表达学习配置列表，支持按聊天流配置 - ["", "enable", "enable", "1.0"], # 全局配置：使用表达，启用学习，学习强度1.0 - ["qq:1919810:group", "enable", "enable", "1.5"], # 特定群聊配置：使用表达，启用学习，学习强度1.5 - ["qq:114514:private", "enable", "disable", "0.5"], # 特定私聊配置：使用表达，禁用学习，学习强度0.5 + ["", "enable", "enable", "enable"], # 全局配置：使用表达，启用学习，启用jargon学习 + ["qq:1919810:group", "enable", "enable", "enable"], # 特定群聊配置：使用表达，启用学习，启用jargon学习 + ["qq:114514:private", "enable", "disable", "disable"], # 特定私聊配置：使用表达，禁用学习，禁用jargon学习 # 格式说明： # 第一位: chat_stream_id，空字符串表示全局配置 # 第二位: 是否使用学到的表达 ("enable"/"disable") # 第三位: 是否学习表达 ("enable"/"disable") - # 第四位: 学习强度（浮点数），影响学习频率，最短学习时间间隔 = 300/学习强度（秒） - # 学习强度越高，学习越频繁；学习强度越低，学习越少 + # 第四位: 是否启用jargon学习 ("enable"/"disable") ] expression_groups = [ @@ -80,12 +91,21 @@ expression_groups = [ # 注意：如果为群聊，则需要设置为group，如果设置为私聊，则需要设置为private ] +reflect = false # 是否启用表达反思（Bot主动向管理员询问表达方式是否合适） +reflect_operator_id = "" # 表达反思操作员ID，格式：platform:id:type (例如 "qq:123456:private" 或 "qq:654321:group") +allow_reflect = [] # 允许进行表达反思的聊天流ID列表，格式：["qq:123456:private", "qq:654321:group", ...]，只有在此列表中的聊天流才会提出问题并跟踪。如果列表为空，则所有聊天流都可以进行表达反思（前提是 reflect = true） -[chat] #麦麦的聊天设置 -talk_value = 1 #聊天频率，越小越沉默，范围0-1 +all_global_jargon = true # 是否开启全局黑话模式，注意，此功能关闭后，已经记录的全局黑话不会改变，需要手动删除 +enable_jargon_explanation = true # 是否在回复前尝试对上下文中的黑话进行解释（关闭可减少一次LLM调用，仅影响回复前的黑话匹配与解释，不影响黑话学习） +jargon_mode = "planner" # 黑话解释来源模式，可选： "context"（使用上下文自动匹配黑话） 或 "planner"（仅使用Planner在reply动作中给出的unknown_words列表） + + +[chat] # 麦麦的聊天设置 +talk_value = 1 # 聊天频率，越小越沉默，范围0-1 mentioned_bot_reply = true # 是否启用提及必回复 max_context_size = 30 # 上下文长度 -planner_smooth = 2 #规划器平滑，增大数值会减小planner负荷，略微降低反应速度，推荐1-5，0为关闭，必须大于等于0 +planner_smooth = 3 # 规划器平滑，增大数值会减小planner负荷，略微降低反应速度，推荐1-5，0为关闭，必须大于等于0 +think_mode = "dynamic" # 思考模式，可选：classic（默认浅度思考和回复）、deep（会进行比较长的，深度回复）、dynamic（动态选择两种模式） enable_talk_value_rules = true # 是否启用动态发言频率规则 @@ -93,7 +113,7 @@ enable_talk_value_rules = true # 是否启用动态发言频率规则 # 推荐格式（对象数组）：{ 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。 +# - 支持跨夜区间，例如 "23:00-02:00"；数值范围建议 0-1，如果 value 设置为0会自动转换为0.0001以避免除以零错误。 talk_value_rules = [ { target = "", time = "00:00-08:59", value = 0.8 }, { target = "", time = "09:00-22:59", value = 1.0 }, @@ -101,22 +121,37 @@ talk_value_rules = [ { target = "qq:114514:private", time = "00:00-23:59", value = 0.3 }, ] -include_planner_reasoning = false # 是否将planner推理加入replyer，默认关闭（不加入） - [memory] -max_agent_iterations = 3 # 记忆思考深度（最低为1（不深入思考）） +max_agent_iterations = 3 # 记忆思考深度（最低为1） +agent_timeout_seconds = 45.0 # 最长回忆时间（秒） +enable_jargon_detection = true # 记忆检索过程中是否启用黑话识别 +global_memory = false # 是否允许记忆检索进行全局查询 -[jargon] -all_global = true # 是否开启全局黑话模式，注意，此功能关闭后，已经记录的全局黑话不会改变，需要手动删除 +[dream] +interval_minutes = 60 # 做梦时间间隔（分钟），默认30分钟 +max_iterations = 20 # 做梦最大轮次，默认20轮 +first_delay_seconds = 1800 # 程序启动后首次做梦前的延迟时间（秒），默认60秒 + +# 做梦结果推送目标，格式为 "platform:user_id" +# 例如: "qq:123456" 表示在做梦结束后，将梦境文本额外发送给该QQ私聊用户。 +# 为空字符串时不推送。 +dream_send = "" + +# 做梦时间段配置，格式：["HH:MM-HH:MM", ...] +# 如果列表为空，则表示全天允许做梦。 +# 如果配置了时间段，则只有在这些时间段内才会实际执行做梦流程。 +# 时间段外，调度器仍会按间隔检查，但不会进入做梦流程。 +# 支持跨夜区间，例如 "23:00-02:00" 表示从23:00到次日02:00。 +# 示例： +dream_time_ranges = [ + # "09:00-22:00", # 白天允许做梦 + "23:00-10:00", # 跨夜时间段（23:00到次日10:00） +] +# dream_time_ranges = [] [tool] enable_tool = true # 是否启用工具 -[mood] -enable_mood = false # 是否启用情绪系统 -mood_update_threshold = 1 # 情绪更新阈值,越高，更新越慢 -# 情感特征，影响情绪的变化情况 -emotion_style = "情绪较为稳定，但遭遇特定事件的时候起伏较大" [emoji] emoji_chance = 0.4 # 麦麦激活表情包动作的概率 @@ -138,37 +173,38 @@ ban_words = [ ban_msgs_regex = [ # 需要过滤的消息（原始消息）匹配的正则表达式，匹配到的消息将被过滤，若不了解正则表达式请勿修改 - #"https?://[^\\s]+", # 匹配https链接 - #"\\d{4}-\\d{2}-\\d{2}", # 匹配日期 + # "https?://[^\\s]+", # 匹配https链接 + # "\\d{4}-\\d{2}-\\d{2}", # 匹配日期 ] [lpmm_knowledge] # lpmm知识库配置 enable = false # 是否启用lpmm知识库 lpmm_mode = "agent" -# 可选：classic经典模式，agent 模式，结合最新的记忆一同使用 -rag_synonym_search_top_k = 10 # 同义词搜索TopK -rag_synonym_threshold = 0.8 # 同义词阈值（相似度高于此阈值的词语会被认为是同义词） -info_extraction_workers = 3 # 实体提取同时执行线程数，非Pro模型不要设置超过5 -qa_relation_search_top_k = 10 # 关系搜索TopK -qa_relation_threshold = 0.5 # 关系阈值（相似度高于此阈值的关系会被认为是相关的关系） -qa_paragraph_search_top_k = 1000 # 段落搜索TopK（不能过小，可能影响搜索结果） +# 可选择classic传统模式/agent 模式，结合新的记忆一同使用 +rag_synonym_search_top_k = 10 # 同义检索TopK +rag_synonym_threshold = 0.8 # 同义阈值，相似度高于该值的关系会被当作同义词 +info_extraction_workers = 3 # 实体抽取同时执行线程数，非Pro模型不要设置超过5 +qa_relation_search_top_k = 10 # 关系检索TopK +qa_relation_threshold = 0.5 # 关系阈值，相似度高于该值的关系会被认为是相关关系 +qa_paragraph_search_top_k = 1000 # 段落检索TopK（不能过小，可能影响搜索结果） qa_paragraph_node_weight = 0.05 # 段落节点权重（在图搜索&PPR计算中的权重，当搜索仅使用DPR时，此参数不起作用） qa_ent_filter_top_k = 10 # 实体过滤TopK qa_ppr_damping = 0.8 # PPR阻尼系数 -qa_res_top_k = 3 # 最终提供的文段TopK -embedding_dimension = 1024 # 嵌入向量维度,应该与模型的输出维度一致 +qa_res_top_k = 3 # 最终提供段落TopK +embedding_dimension = 1024 # 嵌入向量维度,输出维度一致 +# 性能与降级参数（低配机器可下调） +# 低配机器参考：单/双核或内存≤4GB（如轻量云主机/云函数/开发板），建议先关闭PPR并降低并发 +max_embedding_workers = 3 # 嵌入/抽取并发线程数 +embedding_chunk_size = 4 # 每批嵌入的条数 +max_synonym_entities = 2000 # 同义边参与的实体数上限，超限则跳过 +enable_ppr = true # 是否启用PPR，低配机器可关闭 -# keyword_rules 用于设置关键词触发的额外回复知识 -# 添加新规则方法：在 keyword_rules 数组中增加一项，格式如下： -# { keywords = ["关键词1", "关键词2"], reaction = "触发这些关键词时的回复内容" } -# 例如，添加一个新规则：当检测到“你好”或“hello”时回复“你好，有什么可以帮你？” -# { keywords = ["你好", "hello"], reaction = "你好，有什么可以帮你？" } [keyword_reaction] keyword_rules = [ { keywords = ["人机", "bot", "机器", "入机", "robot", "机器人", "ai", "AI"], reaction = "有人说你是人机或者机器人，否定这一事实，攻击或反问他。注意，只有认为你是机器人才回复，否则不要否认" }, { keywords = ["测试关键词回复", "test"], reaction = "回答测试成功" }, - #{ keywords = ["你好", "hello"], reaction = "你好，有什么可以帮你？" } + # { keywords = ["你好", "hello"], reaction = "你好，有什么可以帮你？" } # 在此处添加更多规则，格式同上 ] @@ -216,19 +252,35 @@ show_planner_prompt = false # 是否显示planner的prompt和原始返回结果 show_lpmm_paragraph = false # 是否显示lpmm找到的相关文段日志 [maim_message] -auth_token = [] # 认证令牌，用于API验证，为空则不启用验证 -# 以下项目若要使用需要打开use_custom，并单独配置maim_message的服务器 -use_custom = false # 是否启用自定义的maim_message服务器，注意这需要设置新的端口，不能与.env重复 -host="127.0.0.1" -port=8090 -mode="ws" # 支持ws和tcp两种模式 -use_wss = false # 是否使用WSS安全连接，只支持ws模式 -cert_file = "" # SSL证书文件路径，仅在use_wss=true时有效 -key_file = "" # SSL密钥文件路径，仅在use_wss=true时有效 +auth_token = [] # 认证令牌，用于旧版API验证，为空则不启用验证 + +# 新版API Server配置（额外监听端口） +enable_api_server = false # 是否启用额外的新版API Server +api_server_host = "0.0.0.0" # 新版API Server主机地址 +api_server_port = 8090 # 新版API Server端口号 +api_server_use_wss = false # 新版API Server是否启用WSS +api_server_cert_file = "" # 新版API Server SSL证书文件路径 +api_server_key_file = "" # 新版API Server SSL密钥文件路径 +api_server_allowed_api_keys = [] # 新版API Server允许的API Key列表，为空则允许所有连接 [telemetry] #发送统计信息，主要是看全球有多少只麦麦 enable = true +[webui] # WebUI 独立服务器配置 +# 注意: WebUI 的监听地址(host)和端口(port)已移至 .env 文件中的 WEBUI_HOST 和 WEBUI_PORT +enabled = true # 是否启用WebUI +mode = "production" # 模式: development(开发) 或 production(生产) + +# 防爬虫配置 +anti_crawler_mode = "basic" # 防爬虫模式: false(禁用) / strict(严格) / loose(宽松) / basic(基础-只记录不阻止) +allowed_ips = "127.0.0.1" # IP白名单（逗号分隔，支持精确IP、CIDR格式和通配符） + # 示例: 127.0.0.1,192.168.1.0/24,172.17.0.0/16 +trusted_proxies = "" # 信任的代理IP列表（逗号分隔），只有来自这些IP的X-Forwarded-For才被信任 + # 示例: 127.0.0.1,192.168.1.1,172.17.0.1 +trust_xff = false # 是否启用X-Forwarded-For代理解析（默认false） + # 启用后，仍要求直连IP在trusted_proxies中才会信任XFF头 +secure_cookie = false # 是否启用安全Cookie（仅通过HTTPS传输，默认false） + [experimental] #实验性功能 # 为指定聊天添加额外的prompt配置 # 格式: ["platform:id:type:prompt内容", ...] @@ -241,7 +293,6 @@ enable = true chat_prompts = [] -#此系统暂时移除，无效配置 +# 此系统暂时移除，无效配置 [relationship] enable_relationship = true # 是否启用关系系统 - diff --git a/template/model_config_template.toml b/template/model_config_template.toml index 6d956ace..669488f6 100644 --- a/template/model_config_template.toml +++ b/template/model_config_template.toml @@ -1,5 +1,5 @@ [inner] -version = "1.7.8" +version = "1.9.1" # 配置文件版本号迭代规则同bot_config.toml @@ -46,7 +46,7 @@ name = "deepseek-v3" # 模型名称（可随意命名，在后面 api_provider = "DeepSeek" # API服务商名称（对应在api_providers中配置的服务商名称） price_in = 2.0 # 输入价格（用于API调用统计，单位：元/ M token）（可选，若无该字段，默认值为0） price_out = 8.0 # 输出价格（用于API调用统计，单位：元/ M token）（可选，若无该字段，默认值为0） -#force_stream_mode = true # 强制流式输出模式（若模型不支持非流式输出，请取消该注释，启用强制流式输出，若无该字段，默认值为false） +# force_stream_mode = true # 强制流式输出模式（若模型不支持非流式输出，请取消该注释，启用强制流式输出，若无该字段，默认值为false） [[models]] model_identifier = "deepseek-ai/DeepSeek-V3.2-Exp" @@ -54,17 +54,48 @@ name = "siliconflow-deepseek-v3.2" api_provider = "SiliconFlow" price_in = 2.0 price_out = 3.0 +# temperature = 0.5 # 可选：为该模型单独指定温度，会覆盖任务配置中的温度 +# max_tokens = 4096 # 可选：为该模型单独指定最大token数，会覆盖任务配置中的max_tokens [models.extra_params] # 可选的额外参数配置 enable_thinking = false # 不启用思考 + [[models]] model_identifier = "deepseek-ai/DeepSeek-V3.2-Exp" name = "siliconflow-deepseek-v3.2-think" api_provider = "SiliconFlow" price_in = 2.0 price_out = 3.0 +# temperature = 0.7 # 可选：为该模型单独指定温度，会覆盖任务配置中的温度 +# max_tokens = 4096 # 可选：为该模型单独指定最大token数，会覆盖任务配置中的max_tokens [models.extra_params] # 可选的额外参数配置 -enable_thinking = true # 不启用思考 +enable_thinking = true # 启用思考 + + +[[models]] +model_identifier = "Qwen/Qwen3-Next-80B-A3B-Instruct" +name = "qwen3-next-80b" +api_provider = "SiliconFlow" +price_in = 1.0 +price_out = 4.0 + +[[models]] +model_identifier = "zai-org/GLM-4.6" +name = "siliconflow-glm-4.6" +api_provider = "SiliconFlow" +price_in = 3.5 +price_out = 14.0 +[models.extra_params] # 可选的额外参数配置 +enable_thinking = false # 不启用思考 + +[[models]] +model_identifier = "zai-org/GLM-4.6" +name = "siliconflow-glm-4.6-think" +api_provider = "SiliconFlow" +price_in = 3.5 +price_out = 14.0 +[models.extra_params] # 可选的额外参数配置 +enable_thinking = true # 启用思考 [[models]] model_identifier = "deepseek-ai/DeepSeek-R1" @@ -107,52 +138,63 @@ price_out = 0 [model_task_config.utils] # 在麦麦的一些组件中使用的模型，例如表情包模块，取名模块，关系模块，麦麦的情绪变化等，是麦麦必须的模型 model_list = ["siliconflow-deepseek-v3.2"] # 使用的模型列表，每个子项对应上面的模型名称(name) temperature = 0.2 # 模型温度，新V3建议0.1-0.3 -max_tokens = 2048 # 最大输出token数 +max_tokens = 4096 # 最大输出token数 +slow_threshold = 15.0 # 慢请求阈值（秒），模型等待回复时间超过此值会输出警告日志 [model_task_config.utils_small] # 在麦麦的一些组件中使用的小模型，消耗量较大，建议使用速度较快的小模型 model_list = ["qwen3-30b","qwen3-next-80b"] temperature = 0.7 max_tokens = 2048 +slow_threshold = 10.0 [model_task_config.tool_use] #工具调用模型，需要使用支持工具调用的模型 model_list = ["qwen3-30b","qwen3-next-80b"] temperature = 0.7 max_tokens = 800 +slow_threshold = 10.0 [model_task_config.replyer] # 首要回复模型，还用于表达器和表达方式学习 -model_list = ["siliconflow-deepseek-v3.2-think","siliconflow-glm-4.6-think","siliconflow-glm-4.6"] +model_list = ["siliconflow-deepseek-v3.2","siliconflow-deepseek-v3.2-think","siliconflow-glm-4.6","siliconflow-glm-4.6-think"] temperature = 0.3 # 模型温度，新V3建议0.1-0.3 max_tokens = 2048 +slow_threshold = 25.0 [model_task_config.planner] #决策：负责决定麦麦该什么时候回复的模型 model_list = ["siliconflow-deepseek-v3.2"] temperature = 0.3 max_tokens = 800 +slow_threshold = 12.0 [model_task_config.vlm] # 图像识别模型 model_list = ["qwen3-vl-30"] max_tokens = 256 +slow_threshold = 15.0 [model_task_config.voice] # 语音识别模型 model_list = ["sensevoice-small"] +slow_threshold = 12.0 -#嵌入模型 +# 嵌入模型 [model_task_config.embedding] model_list = ["bge-m3"] +slow_threshold = 5.0 -#------------LPMM知识库模型------------ +# ------------LPMM知识库模型------------ [model_task_config.lpmm_entity_extract] # 实体提取模型 model_list = ["siliconflow-deepseek-v3.2"] temperature = 0.2 max_tokens = 800 +slow_threshold = 20.0 [model_task_config.lpmm_rdf_build] # RDF构建模型 model_list = ["siliconflow-deepseek-v3.2"] temperature = 0.2 max_tokens = 800 +slow_threshold = 20.0 [model_task_config.lpmm_qa] # 问答模型 model_list = ["siliconflow-deepseek-v3.2"] temperature = 0.7 max_tokens = 800 +slow_threshold = 20.0 diff --git a/template/template.env b/template/template.env index b6dd0e5c..23143a71 100644 --- a/template/template.env +++ b/template/template.env @@ -2,8 +2,6 @@ HOST=127.0.0.1 PORT=8000 -# WebUI 独立服务器配置 -WEBUI_ENABLED=true -WEBUI_MODE=production # 模式: development(开发) 或 production(生产) -WEBUI_HOST=0.0.0.0 # WebUI 服务器监听地址 -WEBUI_PORT=8001 # WebUI 服务器端口 \ No newline at end of file +# WebUI 服务器配置 +WEBUI_HOST=127.0.0.1 +WEBUI_PORT=8001 \ No newline at end of file diff --git a/uv.lock b/uv.lock new file mode 100644 index 00000000..788844f4 --- /dev/null +++ b/uv.lock @@ -0,0 +1,2824 @@ +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 = "aiohappyeyeballs" +version = "2.6.1" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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.13.2" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/packages/1c/ce/3b83ebba6b3207a7135e5fcaba49706f8a4b6008153b4e30540c982fae26/aiohttp-3.13.2.tar.gz", hash = "sha256:40176a52c186aefef6eb3cad2cdd30cd06e3afbe88fe8ab2af9c0b90f228daca", size = 7837994, upload_time = "2025-10-28T20:59:39.937Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6d/34/939730e66b716b76046dedfe0842995842fa906ccc4964bba414ff69e429/aiohttp-3.13.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:2372b15a5f62ed37789a6b383ff7344fc5b9f243999b0cd9b629d8bc5f5b4155", size = 736471, upload_time = "2025-10-28T20:55:27.924Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fd/cf/dcbdf2df7f6ca72b0bb4c0b4509701f2d8942cf54e29ca197389c214c07f/aiohttp-3.13.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e7f8659a48995edee7229522984bd1009c1213929c769c2daa80b40fe49a180c", size = 493985, upload_time = "2025-10-28T20:55:29.456Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/9d/87/71c8867e0a1d0882dcbc94af767784c3cb381c1c4db0943ab4aae4fed65e/aiohttp-3.13.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:939ced4a7add92296b0ad38892ce62b98c619288a081170695c6babe4f50e636", size = 489274, upload_time = "2025-10-28T20:55:31.134Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/38/0f/46c24e8dae237295eaadd113edd56dee96ef6462adf19b88592d44891dc5/aiohttp-3.13.2-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6315fb6977f1d0dd41a107c527fee2ed5ab0550b7d885bc15fee20ccb17891da", size = 1668171, upload_time = "2025-10-28T20:55:36.065Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/eb/c6/4cdfb4440d0e28483681a48f69841fa5e39366347d66ef808cbdadddb20e/aiohttp-3.13.2-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6e7352512f763f760baaed2637055c49134fd1d35b37c2dedfac35bfe5cf8725", size = 1636036, upload_time = "2025-10-28T20:55:37.576Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/84/37/8708cf678628216fb678ab327a4e1711c576d6673998f4f43e86e9ae90dd/aiohttp-3.13.2-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e09a0a06348a2dd73e7213353c90d709502d9786219f69b731f6caa0efeb46f5", size = 1727975, upload_time = "2025-10-28T20:55:39.457Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e6/2e/3ebfe12fdcb9b5f66e8a0a42dffcd7636844c8a018f261efb2419f68220b/aiohttp-3.13.2-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a09a6d073fb5789456545bdee2474d14395792faa0527887f2f4ec1a486a59d3", size = 1815823, upload_time = "2025-10-28T20:55:40.958Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a1/4f/ca2ef819488cbb41844c6cf92ca6dd15b9441e6207c58e5ae0e0fc8d70ad/aiohttp-3.13.2-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b59d13c443f8e049d9e94099c7e412e34610f1f49be0f230ec656a10692a5802", size = 1669374, upload_time = "2025-10-28T20:55:42.745Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f8/fe/1fe2e1179a0d91ce09c99069684aab619bf2ccde9b20bd6ca44f8837203e/aiohttp-3.13.2-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:20db2d67985d71ca033443a1ba2001c4b5693fe09b0e29f6d9358a99d4d62a8a", size = 1555315, upload_time = "2025-10-28T20:55:44.264Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5a/2b/f3781899b81c45d7cbc7140cddb8a3481c195e7cbff8e36374759d2ab5a5/aiohttp-3.13.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:960c2fc686ba27b535f9fd2b52d87ecd7e4fd1cf877f6a5cba8afb5b4a8bd204", size = 1639140, upload_time = "2025-10-28T20:55:46.626Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/72/27/c37e85cd3ece6f6c772e549bd5a253d0c122557b25855fb274224811e4f2/aiohttp-3.13.2-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:6c00dbcf5f0d88796151e264a8eab23de2997c9303dd7c0bf622e23b24d3ce22", size = 1645496, upload_time = "2025-10-28T20:55:48.933Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/66/20/3af1ab663151bd3780b123e907761cdb86ec2c4e44b2d9b195ebc91fbe37/aiohttp-3.13.2-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:fed38a5edb7945f4d1bcabe2fcd05db4f6ec7e0e82560088b754f7e08d93772d", size = 1697625, upload_time = "2025-10-28T20:55:50.377Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/95/eb/ae5cab15efa365e13d56b31b0d085a62600298bf398a7986f8388f73b598/aiohttp-3.13.2-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:b395bbca716c38bef3c764f187860e88c724b342c26275bc03e906142fc5964f", size = 1542025, upload_time = "2025-10-28T20:55:51.861Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e9/2d/1683e8d67ec72d911397fe4e575688d2a9b8f6a6e03c8fdc9f3fd3d4c03f/aiohttp-3.13.2-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:204ffff2426c25dfda401ba08da85f9c59525cdc42bda26660463dd1cbcfec6f", size = 1714918, upload_time = "2025-10-28T20:55:53.515Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/99/a2/ffe8e0e1c57c5e542d47ffa1fcf95ef2b3ea573bf7c4d2ee877252431efc/aiohttp-3.13.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:05c4dd3c48fb5f15db31f57eb35374cb0c09afdde532e7fb70a75aede0ed30f6", size = 1656113, upload_time = "2025-10-28T20:55:55.438Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0d/42/d511aff5c3a2b06c09d7d214f508a4ad8ac7799817f7c3d23e7336b5e896/aiohttp-3.13.2-cp310-cp310-win32.whl", hash = "sha256:e574a7d61cf10351d734bcddabbe15ede0eaa8a02070d85446875dc11189a251", size = 432290, upload_time = "2025-10-28T20:55:56.96Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8b/ea/1c2eb7098b5bad4532994f2b7a8228d27674035c9b3234fe02c37469ef14/aiohttp-3.13.2-cp310-cp310-win_amd64.whl", hash = "sha256:364f55663085d658b8462a1c3f17b2b84a5c2e1ba858e1b79bff7b2e24ad1514", size = 455075, upload_time = "2025-10-28T20:55:58.373Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/35/74/b321e7d7ca762638cdf8cdeceb39755d9c745aff7a64c8789be96ddf6e96/aiohttp-3.13.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:4647d02df098f6434bafd7f32ad14942f05a9caa06c7016fdcc816f343997dd0", size = 743409, upload_time = "2025-10-28T20:56:00.354Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/99/3d/91524b905ec473beaf35158d17f82ef5a38033e5809fe8742e3657cdbb97/aiohttp-3.13.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:e3403f24bcb9c3b29113611c3c16a2a447c3953ecf86b79775e7be06f7ae7ccb", size = 497006, upload_time = "2025-10-28T20:56:01.85Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/eb/d3/7f68bc02a67716fe80f063e19adbd80a642e30682ce74071269e17d2dba1/aiohttp-3.13.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:43dff14e35aba17e3d6d5ba628858fb8cb51e30f44724a2d2f0c75be492c55e9", size = 493195, upload_time = "2025-10-28T20:56:03.314Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/98/31/913f774a4708775433b7375c4f867d58ba58ead833af96c8af3621a0d243/aiohttp-3.13.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e2a9ea08e8c58bb17655630198833109227dea914cd20be660f52215f6de5613", size = 1747759, upload_time = "2025-10-28T20:56:04.904Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e8/63/04efe156f4326f31c7c4a97144f82132c3bb21859b7bb84748d452ccc17c/aiohttp-3.13.2-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:53b07472f235eb80e826ad038c9d106c2f653584753f3ddab907c83f49eedead", size = 1704456, upload_time = "2025-10-28T20:56:06.986Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8e/02/4e16154d8e0a9cf4ae76f692941fd52543bbb148f02f098ca73cab9b1c1b/aiohttp-3.13.2-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e736c93e9c274fce6419af4aac199984d866e55f8a4cec9114671d0ea9688780", size = 1807572, upload_time = "2025-10-28T20:56:08.558Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/34/58/b0583defb38689e7f06798f0285b1ffb3a6fb371f38363ce5fd772112724/aiohttp-3.13.2-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ff5e771f5dcbc81c64898c597a434f7682f2259e0cd666932a913d53d1341d1a", size = 1895954, upload_time = "2025-10-28T20:56:10.545Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6b/f3/083907ee3437425b4e376aa58b2c915eb1a33703ec0dc30040f7ae3368c6/aiohttp-3.13.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a3b6fb0c207cc661fa0bf8c66d8d9b657331ccc814f4719468af61034b478592", size = 1747092, upload_time = "2025-10-28T20:56:12.118Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ac/61/98a47319b4e425cc134e05e5f3fc512bf9a04bf65aafd9fdcda5d57ec693/aiohttp-3.13.2-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:97a0895a8e840ab3520e2288db7cace3a1981300d48babeb50e7425609e2e0ab", size = 1606815, upload_time = "2025-10-28T20:56:14.191Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/97/4b/e78b854d82f66bb974189135d31fce265dee0f5344f64dd0d345158a5973/aiohttp-3.13.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:9e8f8afb552297aca127c90cb840e9a1d4bfd6a10d7d8f2d9176e1acc69bad30", size = 1723789, upload_time = "2025-10-28T20:56:16.101Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ed/fc/9d2ccc794fc9b9acd1379d625c3a8c64a45508b5091c546dea273a41929e/aiohttp-3.13.2-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:ed2f9c7216e53c3df02264f25d824b079cc5914f9e2deba94155190ef648ee40", size = 1718104, upload_time = "2025-10-28T20:56:17.655Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/66/65/34564b8765ea5c7d79d23c9113135d1dd3609173da13084830f1507d56cf/aiohttp-3.13.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:99c5280a329d5fa18ef30fd10c793a190d996567667908bef8a7f81f8202b948", size = 1785584, upload_time = "2025-10-28T20:56:19.238Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/30/be/f6a7a426e02fc82781afd62016417b3948e2207426d90a0e478790d1c8a4/aiohttp-3.13.2-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:2ca6ffef405fc9c09a746cb5d019c1672cd7f402542e379afc66b370833170cf", size = 1595126, upload_time = "2025-10-28T20:56:20.836Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e5/c7/8e22d5d28f94f67d2af496f14a83b3c155d915d1fe53d94b66d425ec5b42/aiohttp-3.13.2-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:47f438b1a28e926c37632bff3c44df7d27c9b57aaf4e34b1def3c07111fdb782", size = 1800665, upload_time = "2025-10-28T20:56:22.922Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d1/11/91133c8b68b1da9fc16555706aa7276fdf781ae2bb0876c838dd86b8116e/aiohttp-3.13.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9acda8604a57bb60544e4646a4615c1866ee6c04a8edef9b8ee6fd1d8fa2ddc8", size = 1739532, upload_time = "2025-10-28T20:56:25.924Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/17/6b/3747644d26a998774b21a616016620293ddefa4d63af6286f389aedac844/aiohttp-3.13.2-cp311-cp311-win32.whl", hash = "sha256:868e195e39b24aaa930b063c08bb0c17924899c16c672a28a65afded9c46c6ec", size = 431876, upload_time = "2025-10-28T20:56:27.524Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c3/63/688462108c1a00eb9f05765331c107f95ae86f6b197b865d29e930b7e462/aiohttp-3.13.2-cp311-cp311-win_amd64.whl", hash = "sha256:7fd19df530c292542636c2a9a85854fab93474396a52f1695e799186bbd7f24c", size = 456205, upload_time = "2025-10-28T20:56:29.062Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/29/9b/01f00e9856d0a73260e86dd8ed0c2234a466c5c1712ce1c281548df39777/aiohttp-3.13.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:b1e56bab2e12b2b9ed300218c351ee2a3d8c8fdab5b1ec6193e11a817767e47b", size = 737623, upload_time = "2025-10-28T20:56:30.797Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5a/1b/4be39c445e2b2bd0aab4ba736deb649fabf14f6757f405f0c9685019b9e9/aiohttp-3.13.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:364e25edaabd3d37b1db1f0cbcee8c73c9a3727bfa262b83e5e4cf3489a2a9dc", size = 492664, upload_time = "2025-10-28T20:56:32.708Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/28/66/d35dcfea8050e131cdd731dff36434390479b4045a8d0b9d7111b0a968f1/aiohttp-3.13.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c5c94825f744694c4b8db20b71dba9a257cd2ba8e010a803042123f3a25d50d7", size = 491808, upload_time = "2025-10-28T20:56:34.57Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/00/29/8e4609b93e10a853b65f8291e64985de66d4f5848c5637cddc70e98f01f8/aiohttp-3.13.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ba2715d842ffa787be87cbfce150d5e88c87a98e0b62e0f5aa489169a393dbbb", size = 1738863, upload_time = "2025-10-28T20:56:36.377Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/9d/fa/4ebdf4adcc0def75ced1a0d2d227577cd7b1b85beb7edad85fcc87693c75/aiohttp-3.13.2-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:585542825c4bc662221fb257889e011a5aa00f1ae4d75d1d246a5225289183e3", size = 1700586, upload_time = "2025-10-28T20:56:38.034Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/da/04/73f5f02ff348a3558763ff6abe99c223381b0bace05cd4530a0258e52597/aiohttp-3.13.2-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:39d02cb6025fe1aabca329c5632f48c9532a3dabccd859e7e2f110668972331f", size = 1768625, upload_time = "2025-10-28T20:56:39.75Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f8/49/a825b79ffec124317265ca7d2344a86bcffeb960743487cb11988ffb3494/aiohttp-3.13.2-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e67446b19e014d37342f7195f592a2a948141d15a312fe0e700c2fd2f03124f6", size = 1867281, upload_time = "2025-10-28T20:56:41.471Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b9/48/adf56e05f81eac31edcfae45c90928f4ad50ef2e3ea72cb8376162a368f8/aiohttp-3.13.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4356474ad6333e41ccefd39eae869ba15a6c5299c9c01dfdcfdd5c107be4363e", size = 1752431, upload_time = "2025-10-28T20:56:43.162Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/30/ab/593855356eead019a74e862f21523db09c27f12fd24af72dbc3555b9bfd9/aiohttp-3.13.2-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:eeacf451c99b4525f700f078becff32c32ec327b10dcf31306a8a52d78166de7", size = 1562846, upload_time = "2025-10-28T20:56:44.85Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/39/0f/9f3d32271aa8dc35036e9668e31870a9d3b9542dd6b3e2c8a30931cb27ae/aiohttp-3.13.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d8a9b889aeabd7a4e9af0b7f4ab5ad94d42e7ff679aaec6d0db21e3b639ad58d", size = 1699606, upload_time = "2025-10-28T20:56:46.519Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2c/3c/52d2658c5699b6ef7692a3f7128b2d2d4d9775f2a68093f74bca06cf01e1/aiohttp-3.13.2-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:fa89cb11bc71a63b69568d5b8a25c3ca25b6d54c15f907ca1c130d72f320b76b", size = 1720663, upload_time = "2025-10-28T20:56:48.528Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/9b/d4/8f8f3ff1fb7fb9e3f04fcad4e89d8a1cd8fc7d05de67e3de5b15b33008ff/aiohttp-3.13.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:8aa7c807df234f693fed0ecd507192fc97692e61fee5702cdc11155d2e5cadc8", size = 1737939, upload_time = "2025-10-28T20:56:50.77Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/03/d3/ddd348f8a27a634daae39a1b8e291ff19c77867af438af844bf8b7e3231b/aiohttp-3.13.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:9eb3e33fdbe43f88c3c75fa608c25e7c47bbd80f48d012763cb67c47f39a7e16", size = 1555132, upload_time = "2025-10-28T20:56:52.568Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/39/b8/46790692dc46218406f94374903ba47552f2f9f90dad554eed61bfb7b64c/aiohttp-3.13.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:9434bc0d80076138ea986833156c5a48c9c7a8abb0c96039ddbb4afc93184169", size = 1764802, upload_time = "2025-10-28T20:56:54.292Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ba/e4/19ce547b58ab2a385e5f0b8aa3db38674785085abcf79b6e0edd1632b12f/aiohttp-3.13.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ff15c147b2ad66da1f2cbb0622313f2242d8e6e8f9b79b5206c84523a4473248", size = 1719512, upload_time = "2025-10-28T20:56:56.428Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/70/30/6355a737fed29dcb6dfdd48682d5790cb5eab050f7b4e01f49b121d3acad/aiohttp-3.13.2-cp312-cp312-win32.whl", hash = "sha256:27e569eb9d9e95dbd55c0fc3ec3a9335defbf1d8bc1d20171a49f3c4c607b93e", size = 426690, upload_time = "2025-10-28T20:56:58.736Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0a/0d/b10ac09069973d112de6ef980c1f6bb31cb7dcd0bc363acbdad58f927873/aiohttp-3.13.2-cp312-cp312-win_amd64.whl", hash = "sha256:8709a0f05d59a71f33fd05c17fc11fcb8c30140506e13c2f5e8ee1b8964e1b45", size = 453465, upload_time = "2025-10-28T20:57:00.795Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/bf/78/7e90ca79e5aa39f9694dcfd74f4720782d3c6828113bb1f3197f7e7c4a56/aiohttp-3.13.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:7519bdc7dfc1940d201651b52bf5e03f5503bda45ad6eacf64dda98be5b2b6be", size = 732139, upload_time = "2025-10-28T20:57:02.455Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/db/ed/1f59215ab6853fbaa5c8495fa6cbc39edfc93553426152b75d82a5f32b76/aiohttp-3.13.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:088912a78b4d4f547a1f19c099d5a506df17eacec3c6f4375e2831ec1d995742", size = 490082, upload_time = "2025-10-28T20:57:04.784Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/68/7b/fe0fe0f5e05e13629d893c760465173a15ad0039c0a5b0d0040995c8075e/aiohttp-3.13.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5276807b9de9092af38ed23ce120539ab0ac955547b38563a9ba4f5b07b95293", size = 489035, upload_time = "2025-10-28T20:57:06.894Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d2/04/db5279e38471b7ac801d7d36a57d1230feeee130bbe2a74f72731b23c2b1/aiohttp-3.13.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1237c1375eaef0db4dcd7c2559f42e8af7b87ea7d295b118c60c36a6e61cb811", size = 1720387, upload_time = "2025-10-28T20:57:08.685Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/31/07/8ea4326bd7dae2bd59828f69d7fdc6e04523caa55e4a70f4a8725a7e4ed2/aiohttp-3.13.2-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:96581619c57419c3d7d78703d5b78c1e5e5fc0172d60f555bdebaced82ded19a", size = 1688314, upload_time = "2025-10-28T20:57:10.693Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/48/ab/3d98007b5b87ffd519d065225438cc3b668b2f245572a8cb53da5dd2b1bc/aiohttp-3.13.2-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a2713a95b47374169409d18103366de1050fe0ea73db358fc7a7acb2880422d4", size = 1756317, upload_time = "2025-10-28T20:57:12.563Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/97/3d/801ca172b3d857fafb7b50c7c03f91b72b867a13abca982ed6b3081774ef/aiohttp-3.13.2-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:228a1cd556b3caca590e9511a89444925da87d35219a49ab5da0c36d2d943a6a", size = 1858539, upload_time = "2025-10-28T20:57:14.623Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f7/0d/4764669bdf47bd472899b3d3db91fffbe925c8e3038ec591a2fd2ad6a14d/aiohttp-3.13.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ac6cde5fba8d7d8c6ac963dbb0256a9854e9fafff52fbcc58fdf819357892c3e", size = 1739597, upload_time = "2025-10-28T20:57:16.399Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c4/52/7bd3c6693da58ba16e657eb904a5b6decfc48ecd06e9ac098591653b1566/aiohttp-3.13.2-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f2bef8237544f4e42878c61cef4e2839fee6346dc60f5739f876a9c50be7fcdb", size = 1555006, upload_time = "2025-10-28T20:57:18.288Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/48/30/9586667acec5993b6f41d2ebcf96e97a1255a85f62f3c653110a5de4d346/aiohttp-3.13.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:16f15a4eac3bc2d76c45f7ebdd48a65d41b242eb6c31c2245463b40b34584ded", size = 1683220, upload_time = "2025-10-28T20:57:20.241Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/71/01/3afe4c96854cfd7b30d78333852e8e851dceaec1c40fd00fec90c6402dd2/aiohttp-3.13.2-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:bb7fb776645af5cc58ab804c58d7eba545a97e047254a52ce89c157b5af6cd0b", size = 1712570, upload_time = "2025-10-28T20:57:22.253Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/11/2c/22799d8e720f4697a9e66fd9c02479e40a49de3de2f0bbe7f9f78a987808/aiohttp-3.13.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:e1b4951125ec10c70802f2cb09736c895861cd39fd9dcb35107b4dc8ae6220b8", size = 1733407, upload_time = "2025-10-28T20:57:24.37Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/34/cb/90f15dd029f07cebbd91f8238a8b363978b530cd128488085b5703683594/aiohttp-3.13.2-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:550bf765101ae721ee1d37d8095f47b1f220650f85fe1af37a90ce75bab89d04", size = 1550093, upload_time = "2025-10-28T20:57:26.257Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/69/46/12dce9be9d3303ecbf4d30ad45a7683dc63d90733c2d9fe512be6716cd40/aiohttp-3.13.2-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:fe91b87fc295973096251e2d25a811388e7d8adf3bd2b97ef6ae78bc4ac6c476", size = 1758084, upload_time = "2025-10-28T20:57:28.349Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f9/c8/0932b558da0c302ffd639fc6362a313b98fdf235dc417bc2493da8394df7/aiohttp-3.13.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e0c8e31cfcc4592cb200160344b2fb6ae0f9e4effe06c644b5a125d4ae5ebe23", size = 1716987, upload_time = "2025-10-28T20:57:30.233Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5d/8b/f5bd1a75003daed099baec373aed678f2e9b34f2ad40d85baa1368556396/aiohttp-3.13.2-cp313-cp313-win32.whl", hash = "sha256:0740f31a60848d6edb296a0df827473eede90c689b8f9f2a4cdde74889eb2254", size = 425859, upload_time = "2025-10-28T20:57:32.105Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5d/28/a8a9fc6957b2cee8902414e41816b5ab5536ecf43c3b1843c10e82c559b2/aiohttp-3.13.2-cp313-cp313-win_amd64.whl", hash = "sha256:a88d13e7ca367394908f8a276b89d04a3652044612b9a408a0bb22a5ed976a1a", size = 452192, upload_time = "2025-10-28T20:57:34.166Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/9b/36/e2abae1bd815f01c957cbf7be817b3043304e1c87bad526292a0410fdcf9/aiohttp-3.13.2-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:2475391c29230e063ef53a66669b7b691c9bfc3f1426a0f7bcdf1216bdbac38b", size = 735234, upload_time = "2025-10-28T20:57:36.415Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ca/e3/1ee62dde9b335e4ed41db6bba02613295a0d5b41f74a783c142745a12763/aiohttp-3.13.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:f33c8748abef4d8717bb20e8fb1b3e07c6adacb7fd6beaae971a764cf5f30d61", size = 490733, upload_time = "2025-10-28T20:57:38.205Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/1a/aa/7a451b1d6a04e8d15a362af3e9b897de71d86feac3babf8894545d08d537/aiohttp-3.13.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ae32f24bbfb7dbb485a24b30b1149e2f200be94777232aeadba3eecece4d0aa4", size = 491303, upload_time = "2025-10-28T20:57:40.122Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/57/1e/209958dbb9b01174870f6a7538cd1f3f28274fdbc88a750c238e2c456295/aiohttp-3.13.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5d7f02042c1f009ffb70067326ef183a047425bb2ff3bc434ead4dd4a4a66a2b", size = 1717965, upload_time = "2025-10-28T20:57:42.28Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/08/aa/6a01848d6432f241416bc4866cae8dc03f05a5a884d2311280f6a09c73d6/aiohttp-3.13.2-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:93655083005d71cd6c072cdab54c886e6570ad2c4592139c3fb967bfc19e4694", size = 1667221, upload_time = "2025-10-28T20:57:44.869Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/87/4f/36c1992432d31bbc789fa0b93c768d2e9047ec8c7177e5cd84ea85155f36/aiohttp-3.13.2-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0db1e24b852f5f664cd728db140cf11ea0e82450471232a394b3d1a540b0f906", size = 1757178, upload_time = "2025-10-28T20:57:47.216Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ac/b4/8e940dfb03b7e0f68a82b88fd182b9be0a65cb3f35612fe38c038c3112cf/aiohttp-3.13.2-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b009194665bcd128e23eaddef362e745601afa4641930848af4c8559e88f18f9", size = 1838001, upload_time = "2025-10-28T20:57:49.337Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d7/ef/39f3448795499c440ab66084a9db7d20ca7662e94305f175a80f5b7e0072/aiohttp-3.13.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c038a8fdc8103cd51dbd986ecdce141473ffd9775a7a8057a6ed9c3653478011", size = 1716325, upload_time = "2025-10-28T20:57:51.327Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d7/51/b311500ffc860b181c05d91c59a1313bdd05c82960fdd4035a15740d431e/aiohttp-3.13.2-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:66bac29b95a00db411cd758fea0e4b9bdba6d549dfe333f9a945430f5f2cc5a6", size = 1547978, upload_time = "2025-10-28T20:57:53.554Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/31/64/b9d733296ef79815226dab8c586ff9e3df41c6aff2e16c06697b2d2e6775/aiohttp-3.13.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:4ebf9cfc9ba24a74cf0718f04aac2a3bbe745902cc7c5ebc55c0f3b5777ef213", size = 1682042, upload_time = "2025-10-28T20:57:55.617Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3f/30/43d3e0f9d6473a6db7d472104c4eff4417b1e9df01774cb930338806d36b/aiohttp-3.13.2-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:a4b88ebe35ce54205c7074f7302bd08a4cb83256a3e0870c72d6f68a3aaf8e49", size = 1680085, upload_time = "2025-10-28T20:57:57.59Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/16/51/c709f352c911b1864cfd1087577760ced64b3e5bee2aa88b8c0c8e2e4972/aiohttp-3.13.2-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:98c4fb90bb82b70a4ed79ca35f656f4281885be076f3f970ce315402b53099ae", size = 1728238, upload_time = "2025-10-28T20:57:59.525Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/19/e2/19bd4c547092b773caeb48ff5ae4b1ae86756a0ee76c16727fcfd281404b/aiohttp-3.13.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:ec7534e63ae0f3759df3a1ed4fa6bc8f75082a924b590619c0dd2f76d7043caa", size = 1544395, upload_time = "2025-10-28T20:58:01.914Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/cf/87/860f2803b27dfc5ed7be532832a3498e4919da61299b4a1f8eb89b8ff44d/aiohttp-3.13.2-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:5b927cf9b935a13e33644cbed6c8c4b2d0f25b713d838743f8fe7191b33829c4", size = 1742965, upload_time = "2025-10-28T20:58:03.972Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/67/7f/db2fc7618925e8c7a601094d5cbe539f732df4fb570740be88ed9e40e99a/aiohttp-3.13.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:88d6c017966a78c5265d996c19cdb79235be5e6412268d7e2ce7dee339471b7a", size = 1697585, upload_time = "2025-10-28T20:58:06.189Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0c/07/9127916cb09bb38284db5036036042b7b2c514c8ebaeee79da550c43a6d6/aiohttp-3.13.2-cp314-cp314-win32.whl", hash = "sha256:f7c183e786e299b5d6c49fb43a769f8eb8e04a2726a2bd5887b98b5cc2d67940", size = 431621, upload_time = "2025-10-28T20:58:08.636Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fb/41/554a8a380df6d3a2bba8a7726429a23f4ac62aaf38de43bb6d6cde7b4d4d/aiohttp-3.13.2-cp314-cp314-win_amd64.whl", hash = "sha256:fe242cd381e0fb65758faf5ad96c2e460df6ee5b2de1072fe97e4127927e00b4", size = 457627, upload_time = "2025-10-28T20:58:11Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c7/8e/3824ef98c039d3951cb65b9205a96dd2b20f22241ee17d89c5701557c826/aiohttp-3.13.2-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:f10d9c0b0188fe85398c61147bbd2a657d616c876863bfeff43376e0e3134673", size = 767360, upload_time = "2025-10-28T20:58:13.358Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a4/0f/6a03e3fc7595421274fa34122c973bde2d89344f8a881b728fa8c774e4f1/aiohttp-3.13.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:e7c952aefdf2460f4ae55c5e9c3e80aa72f706a6317e06020f80e96253b1accd", size = 504616, upload_time = "2025-10-28T20:58:15.339Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c6/aa/ed341b670f1bc8a6f2c6a718353d13b9546e2cef3544f573c6a1ff0da711/aiohttp-3.13.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c20423ce14771d98353d2e25e83591fa75dfa90a3c1848f3d7c68243b4fbded3", size = 509131, upload_time = "2025-10-28T20:58:17.693Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/7f/f0/c68dac234189dae5c4bbccc0f96ce0cc16b76632cfc3a08fff180045cfa4/aiohttp-3.13.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e96eb1a34396e9430c19d8338d2ec33015e4a87ef2b4449db94c22412e25ccdf", size = 1864168, upload_time = "2025-10-28T20:58:20.113Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8f/65/75a9a76db8364b5d0e52a0c20eabc5d52297385d9af9c35335b924fafdee/aiohttp-3.13.2-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:23fb0783bc1a33640036465019d3bba069942616a6a2353c6907d7fe1ccdaf4e", size = 1719200, upload_time = "2025-10-28T20:58:22.583Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f5/55/8df2ed78d7f41d232f6bd3ff866b6f617026551aa1d07e2f03458f964575/aiohttp-3.13.2-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2e1a9bea6244a1d05a4e57c295d69e159a5c50d8ef16aa390948ee873478d9a5", size = 1843497, upload_time = "2025-10-28T20:58:24.672Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e9/e0/94d7215e405c5a02ccb6a35c7a3a6cfff242f457a00196496935f700cde5/aiohttp-3.13.2-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0a3d54e822688b56e9f6b5816fb3de3a3a64660efac64e4c2dc435230ad23bad", size = 1935703, upload_time = "2025-10-28T20:58:26.758Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0b/78/1eeb63c3f9b2d1015a4c02788fb543141aad0a03ae3f7a7b669b2483f8d4/aiohttp-3.13.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7a653d872afe9f33497215745da7a943d1dc15b728a9c8da1c3ac423af35178e", size = 1792738, upload_time = "2025-10-28T20:58:29.787Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/41/75/aaf1eea4c188e51538c04cc568040e3082db263a57086ea74a7d38c39e42/aiohttp-3.13.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:56d36e80d2003fa3fc0207fac644216d8532e9504a785ef9a8fd013f84a42c61", size = 1624061, upload_time = "2025-10-28T20:58:32.529Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/9b/c2/3b6034de81fbcc43de8aeb209073a2286dfb50b86e927b4efd81cf848197/aiohttp-3.13.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:78cd586d8331fb8e241c2dd6b2f4061778cc69e150514b39a9e28dd050475661", size = 1789201, upload_time = "2025-10-28T20:58:34.618Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c9/38/c15dcf6d4d890217dae79d7213988f4e5fe6183d43893a9cf2fe9e84ca8d/aiohttp-3.13.2-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:20b10bbfbff766294fe99987f7bb3b74fdd2f1a2905f2562132641ad434dcf98", size = 1776868, upload_time = "2025-10-28T20:58:38.835Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/04/75/f74fd178ac81adf4f283a74847807ade5150e48feda6aef024403716c30c/aiohttp-3.13.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:9ec49dff7e2b3c85cdeaa412e9d438f0ecd71676fde61ec57027dd392f00c693", size = 1790660, upload_time = "2025-10-28T20:58:41.507Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e7/80/7368bd0d06b16b3aba358c16b919e9c46cf11587dc572091031b0e9e3ef0/aiohttp-3.13.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:94f05348c4406450f9d73d38efb41d669ad6cd90c7ee194810d0eefbfa875a7a", size = 1617548, upload_time = "2025-10-28T20:58:43.674Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/7d/4b/a6212790c50483cb3212e507378fbe26b5086d73941e1ec4b56a30439688/aiohttp-3.13.2-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:fa4dcb605c6f82a80c7f95713c2b11c3b8e9893b3ebd2bc9bde93165ed6107be", size = 1817240, upload_time = "2025-10-28T20:58:45.787Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ff/f7/ba5f0ba4ea8d8f3c32850912944532b933acbf0f3a75546b89269b9b7dde/aiohttp-3.13.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cf00e5db968c3f67eccd2778574cf64d8b27d95b237770aa32400bd7a1ca4f6c", size = 1762334, upload_time = "2025-10-28T20:58:47.936Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/7e/83/1a5a1856574588b1cad63609ea9ad75b32a8353ac995d830bf5da9357364/aiohttp-3.13.2-cp314-cp314t-win32.whl", hash = "sha256:d23b5fe492b0805a50d3371e8a728a9134d8de5447dce4c885f5587294750734", size = 464685, upload_time = "2025-10-28T20:58:50.642Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/9f/4d/d22668674122c08f4d56972297c51a624e64b3ed1efaa40187607a7cb66e/aiohttp-3.13.2-cp314-cp314t-win_amd64.whl", hash = "sha256:ff0a7b0a82a7ab905cbda74006318d1b12e37c797eb1b0d4eb3e316cf47f658f", size = 498093, upload_time = "2025-10-28T20:58:52.782Z" }, +] + +[[package]] +name = "aiohttp-cors" +version = "0.8.1" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +dependencies = [ + { name = "aiohttp" }, +] +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6f/6d/d89e846a5444b3d5eb8985a6ddb0daef3774928e1bfbce8e84ec97b0ffa7/aiohttp_cors-0.8.1.tar.gz", hash = "sha256:ccacf9cb84b64939ea15f859a146af1f662a6b1d68175754a07315e305fb1403", size = 38626, upload_time = "2025-03-31T14:16:20.048Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/98/3b/40a68de458904bcc143622015fff2352b6461cd92fd66d3527bf1c6f5716/aiohttp_cors-0.8.1-py3-none-any.whl", hash = "sha256:3180cf304c5c712d626b9162b195b1db7ddf976a2a25172b35bb2448b890a80d", size = 25231, upload_time = "2025-03-31T14:16:18.478Z" }, +] + +[[package]] +name = "aiosignal" +version = "1.4.0" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +dependencies = [ + { name = "frozenlist" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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-doc" +version = "0.0.4" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", hash = "sha256:fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4", size = 7288, upload_time = "2025-11-10T22:07:42.062Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", hash = "sha256:571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320", size = 5303, upload_time = "2025-11-10T22:07:40.673Z" }, +] + +[[package]] +name = "annotated-types" +version = "0.7.0" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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.12.0" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +dependencies = [ + { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, + { name = "idna" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/16/ce/8a777047513153587e5434fd752e89334ac33e379aa3497db860eeb60377/anyio-4.12.0.tar.gz", hash = "sha256:73c693b567b0c55130c104d0b43a9baf3aa6a31fc6110116509f27bf75e21ec0", size = 228266, upload_time = "2025-11-28T23:37:38.911Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/7f/9c/36c5c37947ebfb8c7f22e0eb6e4d188ee2d53aa3880f3f2744fb894f0cb1/anyio-4.12.0-py3-none-any.whl", hash = "sha256:dad2376a628f98eeca4881fc56cd06affd18f659b17a747d3ff0307ced94b1bb", size = 113362, upload_time = "2025-11-28T23:36:57.897Z" }, +] + +[[package]] +name = "async-timeout" +version = "5.0.1" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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.4.0" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6b/5c/685e6633917e101e5dcb62b9dd76946cbb57c26e133bae9e0cd36033c0a9/attrs-25.4.0.tar.gz", hash = "sha256:16d5969b87f0859ef33a48b35d55ac1be6e42ae49d5e853b597db70c35c57e11", size = 934251, upload_time = "2025-10-06T13:54:44.725Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3a/2a/7cc015f5b9f5db42b7d48157e23356022889fc354a2813c15934b7cb5c0e/attrs-25.4.0-py3-none-any.whl", hash = "sha256:adcf7e2a1fb3b36ac48d97835bb6d8ade15b8dcce26aba8bf1d14847b57a3373", size = 67615, upload_time = "2025-10-06T13:54:43.17Z" }, +] + +[[package]] +name = "cachetools" +version = "6.2.2" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fb/44/ca1675be2a83aeee1886ab745b28cda92093066590233cc501890eb8417a/cachetools-6.2.2.tar.gz", hash = "sha256:8e6d266b25e539df852251cfd6f990b4bc3a141db73b939058d809ebd2590fc6", size = 31571, upload_time = "2025-11-13T17:42:51.465Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e6/46/eb6eca305c77a4489affe1c5d8f4cae82f285d9addd8de4ec084a7184221/cachetools-6.2.2-py3-none-any.whl", hash = "sha256:6c09c98183bf58560c97b2abfcedcbaf6a896a490f534b031b661d3723b45ace", size = 11503, upload_time = "2025-11-13T17:42:50.232Z" }, +] + +[[package]] +name = "certifi" +version = "2025.11.12" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a2/8c/58f469717fa48465e4a50c014a0400602d3c437d7c0c468e17ada824da3a/certifi-2025.11.12.tar.gz", hash = "sha256:d8ab5478f2ecd78af242878415affce761ca6bc54a22a27e026d7c25357c3316", size = 160538, upload_time = "2025-11-12T02:54:51.517Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/70/7d/9bc192684cea499815ff478dfcdc13835ddf401365057044fb721ec6bddb/certifi-2025.11.12-py3-none-any.whl", hash = "sha256:97de8790030bbd5c2d96b7ec782fc2f7820ef8dba6db909ccf95449f2d062d4b", size = 159438, upload_time = "2025-11-12T02:54:49.735Z" }, +] + +[[package]] +name = "cffi" +version = "2.0.0" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +dependencies = [ + { name = "pycparser", marker = "implementation_name != 'PyPy'" }, +] +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload_time = "2025-09-08T23:24:04.541Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/93/d7/516d984057745a6cd96575eea814fe1edd6646ee6efd552fb7b0921dec83/cffi-2.0.0-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:0cf2d91ecc3fcc0625c2c530fe004f82c110405f101548512cce44322fa8ac44", size = 184283, upload_time = "2025-09-08T23:22:08.01Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/9e/84/ad6a0b408daa859246f57c03efd28e5dd1b33c21737c2db84cae8c237aa5/cffi-2.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f73b96c41e3b2adedc34a7356e64c8eb96e03a3782b535e043a986276ce12a49", size = 180504, upload_time = "2025-09-08T23:22:10.637Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/50/bd/b1a6362b80628111e6653c961f987faa55262b4002fcec42308cad1db680/cffi-2.0.0-cp310-cp310-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:53f77cbe57044e88bbd5ed26ac1d0514d2acf0591dd6bb02a3ae37f76811b80c", size = 208811, upload_time = "2025-09-08T23:22:12.267Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/4f/27/6933a8b2562d7bd1fb595074cf99cc81fc3789f6a6c05cdabb46284a3188/cffi-2.0.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3e837e369566884707ddaf85fc1744b47575005c0a229de3327f8f9a20f4efeb", size = 216402, upload_time = "2025-09-08T23:22:13.455Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/05/eb/b86f2a2645b62adcfff53b0dd97e8dfafb5c8aa864bd0d9a2c2049a0d551/cffi-2.0.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:5eda85d6d1879e692d546a078b44251cdd08dd1cfb98dfb77b670c97cee49ea0", size = 203217, upload_time = "2025-09-08T23:22:14.596Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/9f/e0/6cbe77a53acf5acc7c08cc186c9928864bd7c005f9efd0d126884858a5fe/cffi-2.0.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9332088d75dc3241c702d852d4671613136d90fa6881da7d770a483fd05248b4", size = 203079, upload_time = "2025-09-08T23:22:15.769Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/98/29/9b366e70e243eb3d14a5cb488dfd3a0b6b2f1fb001a203f653b93ccfac88/cffi-2.0.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fc7de24befaeae77ba923797c7c87834c73648a05a4bde34b3b7e5588973a453", size = 216475, upload_time = "2025-09-08T23:22:17.427Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/21/7a/13b24e70d2f90a322f2900c5d8e1f14fa7e2a6b3332b7309ba7b2ba51a5a/cffi-2.0.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cf364028c016c03078a23b503f02058f1814320a56ad535686f90565636a9495", size = 218829, upload_time = "2025-09-08T23:22:19.069Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/60/99/c9dc110974c59cc981b1f5b66e1d8af8af764e00f0293266824d9c4254bc/cffi-2.0.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e11e82b744887154b182fd3e7e8512418446501191994dbf9c9fc1f32cc8efd5", size = 211211, upload_time = "2025-09-08T23:22:20.588Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/49/72/ff2d12dbf21aca1b32a40ed792ee6b40f6dc3a9cf1644bd7ef6e95e0ac5e/cffi-2.0.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8ea985900c5c95ce9db1745f7933eeef5d314f0565b27625d9a10ec9881e1bfb", size = 218036, upload_time = "2025-09-08T23:22:22.143Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e2/cc/027d7fb82e58c48ea717149b03bcadcbdc293553edb283af792bd4bcbb3f/cffi-2.0.0-cp310-cp310-win32.whl", hash = "sha256:1f72fb8906754ac8a2cc3f9f5aaa298070652a0ffae577e0ea9bd480dc3c931a", size = 172184, upload_time = "2025-09-08T23:22:23.328Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/33/fa/072dd15ae27fbb4e06b437eb6e944e75b068deb09e2a2826039e49ee2045/cffi-2.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:b18a3ed7d5b3bd8d9ef7a8cb226502c6bf8308df1525e1cc676c3680e7176739", size = 182790, upload_time = "2025-09-08T23:22:24.752Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/12/4a/3dfd5f7850cbf0d06dc84ba9aa00db766b52ca38d8b86e3a38314d52498c/cffi-2.0.0-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:b4c854ef3adc177950a8dfc81a86f5115d2abd545751a304c5bcf2c2c7283cfe", size = 184344, upload_time = "2025-09-08T23:22:26.456Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/4f/8b/f0e4c441227ba756aafbe78f117485b25bb26b1c059d01f137fa6d14896b/cffi-2.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2de9a304e27f7596cd03d16f1b7c72219bd944e99cc52b84d0145aefb07cbd3c", size = 180560, upload_time = "2025-09-08T23:22:28.197Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b1/b7/1200d354378ef52ec227395d95c2576330fd22a869f7a70e88e1447eb234/cffi-2.0.0-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:baf5215e0ab74c16e2dd324e8ec067ef59e41125d3eade2b863d294fd5035c92", size = 209613, upload_time = "2025-09-08T23:22:29.475Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b8/56/6033f5e86e8cc9bb629f0077ba71679508bdf54a9a5e112a3c0b91870332/cffi-2.0.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:730cacb21e1bdff3ce90babf007d0a0917cc3e6492f336c2f0134101e0944f93", size = 216476, upload_time = "2025-09-08T23:22:31.063Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/dc/7f/55fecd70f7ece178db2f26128ec41430d8720f2d12ca97bf8f0a628207d5/cffi-2.0.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:6824f87845e3396029f3820c206e459ccc91760e8fa24422f8b0c3d1731cbec5", size = 203374, upload_time = "2025-09-08T23:22:32.507Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/84/ef/a7b77c8bdc0f77adc3b46888f1ad54be8f3b7821697a7b89126e829e676a/cffi-2.0.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9de40a7b0323d889cf8d23d1ef214f565ab154443c42737dfe52ff82cf857664", size = 202597, upload_time = "2025-09-08T23:22:34.132Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d7/91/500d892b2bf36529a75b77958edfcd5ad8e2ce4064ce2ecfeab2125d72d1/cffi-2.0.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8941aaadaf67246224cee8c3803777eed332a19d909b47e29c9842ef1e79ac26", size = 215574, upload_time = "2025-09-08T23:22:35.443Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/44/64/58f6255b62b101093d5df22dcb752596066c7e89dd725e0afaed242a61be/cffi-2.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a05d0c237b3349096d3981b727493e22147f934b20f6f125a3eba8f994bec4a9", size = 218971, upload_time = "2025-09-08T23:22:36.805Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ab/49/fa72cebe2fd8a55fbe14956f9970fe8eb1ac59e5df042f603ef7c8ba0adc/cffi-2.0.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:94698a9c5f91f9d138526b48fe26a199609544591f859c870d477351dc7b2414", size = 211972, upload_time = "2025-09-08T23:22:38.436Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0b/28/dd0967a76aab36731b6ebfe64dec4e981aff7e0608f60c2d46b46982607d/cffi-2.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:5fed36fccc0612a53f1d4d9a816b50a36702c28a2aa880cb8a122b3466638743", size = 217078, upload_time = "2025-09-08T23:22:39.776Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2b/c0/015b25184413d7ab0a410775fdb4a50fca20f5589b5dab1dbbfa3baad8ce/cffi-2.0.0-cp311-cp311-win32.whl", hash = "sha256:c649e3a33450ec82378822b3dad03cc228b8f5963c0c12fc3b1e0ab940f768a5", size = 172076, upload_time = "2025-09-08T23:22:40.95Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ae/8f/dc5531155e7070361eb1b7e4c1a9d896d0cb21c49f807a6c03fd63fc877e/cffi-2.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:66f011380d0e49ed280c789fbd08ff0d40968ee7b665575489afa95c98196ab5", size = 182820, upload_time = "2025-09-08T23:22:42.463Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/95/5c/1b493356429f9aecfd56bc171285a4c4ac8697f76e9bbbbb105e537853a1/cffi-2.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:c6638687455baf640e37344fe26d37c404db8b80d037c3d29f58fe8d1c3b194d", size = 177635, upload_time = "2025-09-08T23:22:43.623Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ea/47/4f61023ea636104d4f16ab488e268b93008c3d0bb76893b1b31db1f96802/cffi-2.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d", size = 185271, upload_time = "2025-09-08T23:22:44.795Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/df/a2/781b623f57358e360d62cdd7a8c681f074a71d445418a776eef0aadb4ab4/cffi-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c", size = 181048, upload_time = "2025-09-08T23:22:45.938Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ff/df/a4f0fbd47331ceeba3d37c2e51e9dfc9722498becbeec2bd8bc856c9538a/cffi-2.0.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe", size = 212529, upload_time = "2025-09-08T23:22:47.349Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d5/72/12b5f8d3865bf0f87cf1404d8c374e7487dcf097a1c91c436e72e6badd83/cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062", size = 220097, upload_time = "2025-09-08T23:22:48.677Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c2/95/7a135d52a50dfa7c882ab0ac17e8dc11cec9d55d2c18dda414c051c5e69e/cffi-2.0.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e", size = 207983, upload_time = "2025-09-08T23:22:50.06Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3a/c8/15cb9ada8895957ea171c62dc78ff3e99159ee7adb13c0123c001a2546c1/cffi-2.0.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037", size = 206519, upload_time = "2025-09-08T23:22:51.364Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba", size = 219572, upload_time = "2025-09-08T23:22:52.902Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/07/e0/267e57e387b4ca276b90f0434ff88b2c2241ad72b16d31836adddfd6031b/cffi-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94", size = 222963, upload_time = "2025-09-08T23:22:54.518Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b6/75/1f2747525e06f53efbd878f4d03bac5b859cbc11c633d0fb81432d98a795/cffi-2.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187", size = 221361, upload_time = "2025-09-08T23:22:55.867Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/7b/2b/2b6435f76bfeb6bbf055596976da087377ede68df465419d192acf00c437/cffi-2.0.0-cp312-cp312-win32.whl", hash = "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18", size = 172932, upload_time = "2025-09-08T23:22:57.188Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f8/ed/13bd4418627013bec4ed6e54283b1959cf6db888048c7cf4b4c3b5b36002/cffi-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5", size = 183557, upload_time = "2025-09-08T23:22:58.351Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/95/31/9f7f93ad2f8eff1dbc1c3656d7ca5bfd8fb52c9d786b4dcf19b2d02217fa/cffi-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6", size = 177762, upload_time = "2025-09-08T23:22:59.668Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/4b/8d/a0a47a0c9e413a658623d014e91e74a50cdd2c423f7ccfd44086ef767f90/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb", size = 185230, upload_time = "2025-09-08T23:23:00.879Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/4a/d2/a6c0296814556c68ee32009d9c2ad4f85f2707cdecfd7727951ec228005d/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca", size = 181043, upload_time = "2025-09-08T23:23:02.231Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b0/1e/d22cc63332bd59b06481ceaac49d6c507598642e2230f201649058a7e704/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b", size = 212446, upload_time = "2025-09-08T23:23:03.472Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a9/f5/a2c23eb03b61a0b8747f211eb716446c826ad66818ddc7810cc2cc19b3f2/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b", size = 220101, upload_time = "2025-09-08T23:23:04.792Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f2/7f/e6647792fc5850d634695bc0e6ab4111ae88e89981d35ac269956605feba/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2", size = 207948, upload_time = "2025-09-08T23:23:06.127Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/cb/1e/a5a1bd6f1fb30f22573f76533de12a00bf274abcdc55c8edab639078abb6/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3", size = 206422, upload_time = "2025-09-08T23:23:07.753Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/98/df/0a1755e750013a2081e863e7cd37e0cdd02664372c754e5560099eb7aa44/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26", size = 219499, upload_time = "2025-09-08T23:23:09.648Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/50/e1/a969e687fcf9ea58e6e2a928ad5e2dd88cc12f6f0ab477e9971f2309b57c/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c", size = 222928, upload_time = "2025-09-08T23:23:10.928Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/36/54/0362578dd2c9e557a28ac77698ed67323ed5b9775ca9d3fe73fe191bb5d8/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b", size = 221302, upload_time = "2025-09-08T23:23:12.42Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909, upload_time = "2025-09-08T23:23:14.32Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402, upload_time = "2025-09-08T23:23:15.535Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780, upload_time = "2025-09-08T23:23:16.761Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/92/c4/3ce07396253a83250ee98564f8d7e9789fab8e58858f35d07a9a2c78de9f/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5", size = 185320, upload_time = "2025-09-08T23:23:18.087Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/59/dd/27e9fa567a23931c838c6b02d0764611c62290062a6d4e8ff7863daf9730/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13", size = 181487, upload_time = "2025-09-08T23:23:19.622Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d6/43/0e822876f87ea8a4ef95442c3d766a06a51fc5298823f884ef87aaad168c/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b", size = 220049, upload_time = "2025-09-08T23:23:20.853Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b4/89/76799151d9c2d2d1ead63c2429da9ea9d7aac304603de0c6e8764e6e8e70/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c", size = 207793, upload_time = "2025-09-08T23:23:22.08Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/bb/dd/3465b14bb9e24ee24cb88c9e3730f6de63111fffe513492bf8c808a3547e/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef", size = 206300, upload_time = "2025-09-08T23:23:23.314Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/47/d9/d83e293854571c877a92da46fdec39158f8d7e68da75bf73581225d28e90/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775", size = 219244, upload_time = "2025-09-08T23:23:24.541Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2b/0f/1f177e3683aead2bb00f7679a16451d302c436b5cbf2505f0ea8146ef59e/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205", size = 222828, upload_time = "2025-09-08T23:23:26.143Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c6/0f/cafacebd4b040e3119dcb32fed8bdef8dfe94da653155f9d0b9dc660166e/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1", size = 220926, upload_time = "2025-09-08T23:23:27.873Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3e/aa/df335faa45b395396fcbc03de2dfcab242cd61a9900e914fe682a59170b1/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f", size = 175328, upload_time = "2025-09-08T23:23:44.61Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/bb/92/882c2d30831744296ce713f0feb4c1cd30f346ef747b530b5318715cc367/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25", size = 185650, upload_time = "2025-09-08T23:23:45.848Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/9f/2c/98ece204b9d35a7366b5b2c6539c350313ca13932143e79dc133ba757104/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad", size = 180687, upload_time = "2025-09-08T23:23:47.105Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3e/61/c768e4d548bfa607abcda77423448df8c471f25dbe64fb2ef6d555eae006/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9", size = 188773, upload_time = "2025-09-08T23:23:29.347Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2c/ea/5f76bce7cf6fcd0ab1a1058b5af899bfbef198bea4d5686da88471ea0336/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d", size = 185013, upload_time = "2025-09-08T23:23:30.63Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/be/b4/c56878d0d1755cf9caa54ba71e5d049479c52f9e4afc230f06822162ab2f/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c", size = 221593, upload_time = "2025-09-08T23:23:31.91Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e0/0d/eb704606dfe8033e7128df5e90fee946bbcb64a04fcdaa97321309004000/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8", size = 209354, upload_time = "2025-09-08T23:23:33.214Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d8/19/3c435d727b368ca475fb8742ab97c9cb13a0de600ce86f62eab7fa3eea60/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc", size = 208480, upload_time = "2025-09-08T23:23:34.495Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d0/44/681604464ed9541673e486521497406fadcc15b5217c3e326b061696899a/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592", size = 221584, upload_time = "2025-09-08T23:23:36.096Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/25/8e/342a504ff018a2825d395d44d63a767dd8ebc927ebda557fecdaca3ac33a/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512", size = 224443, upload_time = "2025-09-08T23:23:37.328Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437, upload_time = "2025-09-08T23:23:38.945Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a0/1d/ec1a60bd1a10daa292d3cd6bb0b359a81607154fb8165f3ec95fe003b85c/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e", size = 180487, upload_time = "2025-09-08T23:23:40.423Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/bf/41/4c1168c74fac325c0c8156f04b6749c8b6a8f405bbf91413ba088359f60d/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6", size = 191726, upload_time = "2025-09-08T23:23:41.742Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195, upload_time = "2025-09-08T23:23:43.004Z" }, +] + +[[package]] +name = "charset-normalizer" +version = "3.4.4" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/13/69/33ddede1939fdd074bce5434295f38fae7136463422fe4fd3e0e89b98062/charset_normalizer-3.4.4.tar.gz", hash = "sha256:94537985111c35f28720e43603b8e7b43a6ecfb2ce1d3058bbe955b73404e21a", size = 129418, upload_time = "2025-10-14T04:42:32.879Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/1f/b8/6d51fc1d52cbd52cd4ccedd5b5b2f0f6a11bbf6765c782298b0f3e808541/charset_normalizer-3.4.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:e824f1492727fa856dd6eda4f7cee25f8518a12f3c4a56a74e8095695089cf6d", size = 209709, upload_time = "2025-10-14T04:40:11.385Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5c/af/1f9d7f7faafe2ddfb6f72a2e07a548a629c61ad510fe60f9630309908fef/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4bd5d4137d500351a30687c2d3971758aac9a19208fc110ccb9d7188fbe709e8", size = 148814, upload_time = "2025-10-14T04:40:13.135Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/79/3d/f2e3ac2bbc056ca0c204298ea4e3d9db9b4afe437812638759db2c976b5f/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:027f6de494925c0ab2a55eab46ae5129951638a49a34d87f4c3eda90f696b4ad", size = 144467, upload_time = "2025-10-14T04:40:14.728Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ec/85/1bf997003815e60d57de7bd972c57dc6950446a3e4ccac43bc3070721856/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f820802628d2694cb7e56db99213f930856014862f3fd943d290ea8438d07ca8", size = 162280, upload_time = "2025-10-14T04:40:16.14Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3e/8e/6aa1952f56b192f54921c436b87f2aaf7c7a7c3d0d1a765547d64fd83c13/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:798d75d81754988d2565bff1b97ba5a44411867c0cf32b77a7e8f8d84796b10d", size = 159454, upload_time = "2025-10-14T04:40:17.567Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/36/3b/60cbd1f8e93aa25d1c669c649b7a655b0b5fb4c571858910ea9332678558/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d1bb833febdff5c8927f922386db610b49db6e0d4f4ee29601d71e7c2694313", size = 153609, upload_time = "2025-10-14T04:40:19.08Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/64/91/6a13396948b8fd3c4b4fd5bc74d045f5637d78c9675585e8e9fbe5636554/charset_normalizer-3.4.4-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9cd98cdc06614a2f768d2b7286d66805f94c48cde050acdbbb7db2600ab3197e", size = 151849, upload_time = "2025-10-14T04:40:20.607Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b7/7a/59482e28b9981d105691e968c544cc0df3b7d6133152fb3dcdc8f135da7a/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:077fbb858e903c73f6c9db43374fd213b0b6a778106bc7032446a8e8b5b38b93", size = 151586, upload_time = "2025-10-14T04:40:21.719Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/92/59/f64ef6a1c4bdd2baf892b04cd78792ed8684fbc48d4c2afe467d96b4df57/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:244bfb999c71b35de57821b8ea746b24e863398194a4014e4c76adc2bbdfeff0", size = 145290, upload_time = "2025-10-14T04:40:23.069Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6b/63/3bf9f279ddfa641ffa1962b0db6a57a9c294361cc2f5fcac997049a00e9c/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:64b55f9dce520635f018f907ff1b0df1fdc31f2795a922fb49dd14fbcdf48c84", size = 163663, upload_time = "2025-10-14T04:40:24.17Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ed/09/c9e38fc8fa9e0849b172b581fd9803bdf6e694041127933934184e19f8c3/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:faa3a41b2b66b6e50f84ae4a68c64fcd0c44355741c6374813a800cd6695db9e", size = 151964, upload_time = "2025-10-14T04:40:25.368Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d2/d1/d28b747e512d0da79d8b6a1ac18b7ab2ecfd81b2944c4c710e166d8dd09c/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:6515f3182dbe4ea06ced2d9e8666d97b46ef4c75e326b79bb624110f122551db", size = 161064, upload_time = "2025-10-14T04:40:26.806Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/bb/9a/31d62b611d901c3b9e5500c36aab0ff5eb442043fb3a1c254200d3d397d9/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:cc00f04ed596e9dc0da42ed17ac5e596c6ccba999ba6bd92b0e0aef2f170f2d6", size = 155015, upload_time = "2025-10-14T04:40:28.284Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/1f/f3/107e008fa2bff0c8b9319584174418e5e5285fef32f79d8ee6a430d0039c/charset_normalizer-3.4.4-cp310-cp310-win32.whl", hash = "sha256:f34be2938726fc13801220747472850852fe6b1ea75869a048d6f896838c896f", size = 99792, upload_time = "2025-10-14T04:40:29.613Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/eb/66/e396e8a408843337d7315bab30dbf106c38966f1819f123257f5520f8a96/charset_normalizer-3.4.4-cp310-cp310-win_amd64.whl", hash = "sha256:a61900df84c667873b292c3de315a786dd8dac506704dea57bc957bd31e22c7d", size = 107198, upload_time = "2025-10-14T04:40:30.644Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b5/58/01b4f815bf0312704c267f2ccb6e5d42bcc7752340cd487bc9f8c3710597/charset_normalizer-3.4.4-cp310-cp310-win_arm64.whl", hash = "sha256:cead0978fc57397645f12578bfd2d5ea9138ea0fac82b2f63f7f7c6877986a69", size = 100262, upload_time = "2025-10-14T04:40:32.108Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ed/27/c6491ff4954e58a10f69ad90aca8a1b6fe9c5d3c6f380907af3c37435b59/charset_normalizer-3.4.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6e1fcf0720908f200cd21aa4e6750a48ff6ce4afe7ff5a79a90d5ed8a08296f8", size = 206988, upload_time = "2025-10-14T04:40:33.79Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/94/59/2e87300fe67ab820b5428580a53cad894272dbb97f38a7a814a2a1ac1011/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f819d5fe9234f9f82d75bdfa9aef3a3d72c4d24a6e57aeaebba32a704553aa0", size = 147324, upload_time = "2025-10-14T04:40:34.961Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/07/fb/0cf61dc84b2b088391830f6274cb57c82e4da8bbc2efeac8c025edb88772/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a59cb51917aa591b1c4e6a43c132f0cdc3c76dbad6155df4e28ee626cc77a0a3", size = 142742, upload_time = "2025-10-14T04:40:36.105Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/62/8b/171935adf2312cd745d290ed93cf16cf0dfe320863ab7cbeeae1dcd6535f/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8ef3c867360f88ac904fd3f5e1f902f13307af9052646963ee08ff4f131adafc", size = 160863, upload_time = "2025-10-14T04:40:37.188Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/09/73/ad875b192bda14f2173bfc1bc9a55e009808484a4b256748d931b6948442/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d9e45d7faa48ee908174d8fe84854479ef838fc6a705c9315372eacbc2f02897", size = 157837, upload_time = "2025-10-14T04:40:38.435Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6d/fc/de9cce525b2c5b94b47c70a4b4fb19f871b24995c728e957ee68ab1671ea/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:840c25fb618a231545cbab0564a799f101b63b9901f2569faecd6b222ac72381", size = 151550, upload_time = "2025-10-14T04:40:40.053Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/55/c2/43edd615fdfba8c6f2dfbd459b25a6b3b551f24ea21981e23fb768503ce1/charset_normalizer-3.4.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ca5862d5b3928c4940729dacc329aa9102900382fea192fc5e52eb69d6093815", size = 149162, upload_time = "2025-10-14T04:40:41.163Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/03/86/bde4ad8b4d0e9429a4e82c1e8f5c659993a9a863ad62c7df05cf7b678d75/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d9c7f57c3d666a53421049053eaacdd14bbd0a528e2186fcb2e672effd053bb0", size = 150019, upload_time = "2025-10-14T04:40:42.276Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/1f/86/a151eb2af293a7e7bac3a739b81072585ce36ccfb4493039f49f1d3cae8c/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:277e970e750505ed74c832b4bf75dac7476262ee2a013f5574dd49075879e161", size = 143310, upload_time = "2025-10-14T04:40:43.439Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b5/fe/43dae6144a7e07b87478fdfc4dbe9efd5defb0e7ec29f5f58a55aeef7bf7/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:31fd66405eaf47bb62e8cd575dc621c56c668f27d46a61d975a249930dd5e2a4", size = 162022, upload_time = "2025-10-14T04:40:44.547Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/80/e6/7aab83774f5d2bca81f42ac58d04caf44f0cc2b65fc6db2b3b2e8a05f3b3/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:0d3d8f15c07f86e9ff82319b3d9ef6f4bf907608f53fe9d92b28ea9ae3d1fd89", size = 149383, upload_time = "2025-10-14T04:40:46.018Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/4f/e8/b289173b4edae05c0dde07f69f8db476a0b511eac556dfe0d6bda3c43384/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:9f7fcd74d410a36883701fafa2482a6af2ff5ba96b9a620e9e0721e28ead5569", size = 159098, upload_time = "2025-10-14T04:40:47.081Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d8/df/fe699727754cae3f8478493c7f45f777b17c3ef0600e28abfec8619eb49c/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ebf3e58c7ec8a8bed6d66a75d7fb37b55e5015b03ceae72a8e7c74495551e224", size = 152991, upload_time = "2025-10-14T04:40:48.246Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/1a/86/584869fe4ddb6ffa3bd9f491b87a01568797fb9bd8933f557dba9771beaf/charset_normalizer-3.4.4-cp311-cp311-win32.whl", hash = "sha256:eecbc200c7fd5ddb9a7f16c7decb07b566c29fa2161a16cf67b8d068bd21690a", size = 99456, upload_time = "2025-10-14T04:40:49.376Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/65/f6/62fdd5feb60530f50f7e38b4f6a1d5203f4d16ff4f9f0952962c044e919a/charset_normalizer-3.4.4-cp311-cp311-win_amd64.whl", hash = "sha256:5ae497466c7901d54b639cf42d5b8c1b6a4fead55215500d2f486d34db48d016", size = 106978, upload_time = "2025-10-14T04:40:50.844Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/7a/9d/0710916e6c82948b3be62d9d398cb4fcf4e97b56d6a6aeccd66c4b2f2bd5/charset_normalizer-3.4.4-cp311-cp311-win_arm64.whl", hash = "sha256:65e2befcd84bc6f37095f5961e68a6f077bf44946771354a28ad434c2cce0ae1", size = 99969, upload_time = "2025-10-14T04:40:52.272Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f3/85/1637cd4af66fa687396e757dec650f28025f2a2f5a5531a3208dc0ec43f2/charset_normalizer-3.4.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0a98e6759f854bd25a58a73fa88833fba3b7c491169f86ce1180c948ab3fd394", size = 208425, upload_time = "2025-10-14T04:40:53.353Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/9d/6a/04130023fef2a0d9c62d0bae2649b69f7b7d8d24ea5536feef50551029df/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b5b290ccc2a263e8d185130284f8501e3e36c5e02750fc6b6bdeb2e9e96f1e25", size = 148162, upload_time = "2025-10-14T04:40:54.558Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/78/29/62328d79aa60da22c9e0b9a66539feae06ca0f5a4171ac4f7dc285b83688/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74bb723680f9f7a6234dcf67aea57e708ec1fbdf5699fb91dfd6f511b0a320ef", size = 144558, upload_time = "2025-10-14T04:40:55.677Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/86/bb/b32194a4bf15b88403537c2e120b817c61cd4ecffa9b6876e941c3ee38fe/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f1e34719c6ed0b92f418c7c780480b26b5d9c50349e9a9af7d76bf757530350d", size = 161497, upload_time = "2025-10-14T04:40:57.217Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/19/89/a54c82b253d5b9b111dc74aca196ba5ccfcca8242d0fb64146d4d3183ff1/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2437418e20515acec67d86e12bf70056a33abdacb5cb1655042f6538d6b085a8", size = 159240, upload_time = "2025-10-14T04:40:58.358Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c0/10/d20b513afe03acc89ec33948320a5544d31f21b05368436d580dec4e234d/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11d694519d7f29d6cd09f6ac70028dba10f92f6cdd059096db198c283794ac86", size = 153471, upload_time = "2025-10-14T04:40:59.468Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/61/fa/fbf177b55bdd727010f9c0a3c49eefa1d10f960e5f09d1d887bf93c2e698/charset_normalizer-3.4.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ac1c4a689edcc530fc9d9aa11f5774b9e2f33f9a0c6a57864e90908f5208d30a", size = 150864, upload_time = "2025-10-14T04:41:00.623Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/05/12/9fbc6a4d39c0198adeebbde20b619790e9236557ca59fc40e0e3cebe6f40/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:21d142cc6c0ec30d2efee5068ca36c128a30b0f2c53c1c07bd78cb6bc1d3be5f", size = 150647, upload_time = "2025-10-14T04:41:01.754Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ad/1f/6a9a593d52e3e8c5d2b167daf8c6b968808efb57ef4c210acb907c365bc4/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5dbe56a36425d26d6cfb40ce79c314a2e4dd6211d51d6d2191c00bed34f354cc", size = 145110, upload_time = "2025-10-14T04:41:03.231Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/30/42/9a52c609e72471b0fc54386dc63c3781a387bb4fe61c20231a4ebcd58bdd/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:5bfbb1b9acf3334612667b61bd3002196fe2a1eb4dd74d247e0f2a4d50ec9bbf", size = 162839, upload_time = "2025-10-14T04:41:04.715Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c4/5b/c0682bbf9f11597073052628ddd38344a3d673fda35a36773f7d19344b23/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:d055ec1e26e441f6187acf818b73564e6e6282709e9bcb5b63f5b23068356a15", size = 150667, upload_time = "2025-10-14T04:41:05.827Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e4/24/a41afeab6f990cf2daf6cb8c67419b63b48cf518e4f56022230840c9bfb2/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:af2d8c67d8e573d6de5bc30cdb27e9b95e49115cd9baad5ddbd1a6207aaa82a9", size = 160535, upload_time = "2025-10-14T04:41:06.938Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2a/e5/6a4ce77ed243c4a50a1fecca6aaaab419628c818a49434be428fe24c9957/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:780236ac706e66881f3b7f2f32dfe90507a09e67d1d454c762cf642e6e1586e0", size = 154816, upload_time = "2025-10-14T04:41:08.101Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a8/ef/89297262b8092b312d29cdb2517cb1237e51db8ecef2e9af5edbe7b683b1/charset_normalizer-3.4.4-cp312-cp312-win32.whl", hash = "sha256:5833d2c39d8896e4e19b689ffc198f08ea58116bee26dea51e362ecc7cd3ed26", size = 99694, upload_time = "2025-10-14T04:41:09.23Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3d/2d/1e5ed9dd3b3803994c155cd9aacb60c82c331bad84daf75bcb9c91b3295e/charset_normalizer-3.4.4-cp312-cp312-win_amd64.whl", hash = "sha256:a79cfe37875f822425b89a82333404539ae63dbdddf97f84dcbc3d339aae9525", size = 107131, upload_time = "2025-10-14T04:41:10.467Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d0/d9/0ed4c7098a861482a7b6a95603edce4c0d9db2311af23da1fb2b75ec26fc/charset_normalizer-3.4.4-cp312-cp312-win_arm64.whl", hash = "sha256:376bec83a63b8021bb5c8ea75e21c4ccb86e7e45ca4eb81146091b56599b80c3", size = 100390, upload_time = "2025-10-14T04:41:11.915Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/97/45/4b3a1239bbacd321068ea6e7ac28875b03ab8bc0aa0966452db17cd36714/charset_normalizer-3.4.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e1f185f86a6f3403aa2420e815904c67b2f9ebc443f045edd0de921108345794", size = 208091, upload_time = "2025-10-14T04:41:13.346Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/7d/62/73a6d7450829655a35bb88a88fca7d736f9882a27eacdca2c6d505b57e2e/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b39f987ae8ccdf0d2642338faf2abb1862340facc796048b604ef14919e55ed", size = 147936, upload_time = "2025-10-14T04:41:14.461Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/89/c5/adb8c8b3d6625bef6d88b251bbb0d95f8205831b987631ab0c8bb5d937c2/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3162d5d8ce1bb98dd51af660f2121c55d0fa541b46dff7bb9b9f86ea1d87de72", size = 144180, upload_time = "2025-10-14T04:41:15.588Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/91/ed/9706e4070682d1cc219050b6048bfd293ccf67b3d4f5a4f39207453d4b99/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:81d5eb2a312700f4ecaa977a8235b634ce853200e828fbadf3a9c50bab278328", size = 161346, upload_time = "2025-10-14T04:41:16.738Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d5/0d/031f0d95e4972901a2f6f09ef055751805ff541511dc1252ba3ca1f80cf5/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5bd2293095d766545ec1a8f612559f6b40abc0eb18bb2f5d1171872d34036ede", size = 158874, upload_time = "2025-10-14T04:41:17.923Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f5/83/6ab5883f57c9c801ce5e5677242328aa45592be8a00644310a008d04f922/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8a8b89589086a25749f471e6a900d3f662d1d3b6e2e59dcecf787b1cc3a1894", size = 153076, upload_time = "2025-10-14T04:41:19.106Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/75/1e/5ff781ddf5260e387d6419959ee89ef13878229732732ee73cdae01800f2/charset_normalizer-3.4.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc7637e2f80d8530ee4a78e878bce464f70087ce73cf7c1caf142416923b98f1", size = 150601, upload_time = "2025-10-14T04:41:20.245Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d7/57/71be810965493d3510a6ca79b90c19e48696fb1ff964da319334b12677f0/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f8bf04158c6b607d747e93949aa60618b61312fe647a6369f88ce2ff16043490", size = 150376, upload_time = "2025-10-14T04:41:21.398Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e5/d5/c3d057a78c181d007014feb7e9f2e65905a6c4ef182c0ddf0de2924edd65/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:554af85e960429cf30784dd47447d5125aaa3b99a6f0683589dbd27e2f45da44", size = 144825, upload_time = "2025-10-14T04:41:22.583Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e6/8c/d0406294828d4976f275ffbe66f00266c4b3136b7506941d87c00cab5272/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:74018750915ee7ad843a774364e13a3db91682f26142baddf775342c3f5b1133", size = 162583, upload_time = "2025-10-14T04:41:23.754Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d7/24/e2aa1f18c8f15c4c0e932d9287b8609dd30ad56dbe41d926bd846e22fb8d/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c0463276121fdee9c49b98908b3a89c39be45d86d1dbaa22957e38f6321d4ce3", size = 150366, upload_time = "2025-10-14T04:41:25.27Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e4/5b/1e6160c7739aad1e2df054300cc618b06bf784a7a164b0f238360721ab86/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:362d61fd13843997c1c446760ef36f240cf81d3ebf74ac62652aebaf7838561e", size = 160300, upload_time = "2025-10-14T04:41:26.725Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/7a/10/f882167cd207fbdd743e55534d5d9620e095089d176d55cb22d5322f2afd/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a26f18905b8dd5d685d6d07b0cdf98a79f3c7a918906af7cc143ea2e164c8bc", size = 154465, upload_time = "2025-10-14T04:41:28.322Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/89/66/c7a9e1b7429be72123441bfdbaf2bc13faab3f90b933f664db506dea5915/charset_normalizer-3.4.4-cp313-cp313-win32.whl", hash = "sha256:9b35f4c90079ff2e2edc5b26c0c77925e5d2d255c42c74fdb70fb49b172726ac", size = 99404, upload_time = "2025-10-14T04:41:29.95Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c4/26/b9924fa27db384bdcd97ab83b4f0a8058d96ad9626ead570674d5e737d90/charset_normalizer-3.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:b435cba5f4f750aa6c0a0d92c541fb79f69a387c91e61f1795227e4ed9cece14", size = 107092, upload_time = "2025-10-14T04:41:31.188Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/af/8f/3ed4bfa0c0c72a7ca17f0380cd9e4dd842b09f664e780c13cff1dcf2ef1b/charset_normalizer-3.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:542d2cee80be6f80247095cc36c418f7bddd14f4a6de45af91dfad36d817bba2", size = 100408, upload_time = "2025-10-14T04:41:32.624Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2a/35/7051599bd493e62411d6ede36fd5af83a38f37c4767b92884df7301db25d/charset_normalizer-3.4.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:da3326d9e65ef63a817ecbcc0df6e94463713b754fe293eaa03da99befb9a5bd", size = 207746, upload_time = "2025-10-14T04:41:33.773Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/10/9a/97c8d48ef10d6cd4fcead2415523221624bf58bcf68a802721a6bc807c8f/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8af65f14dc14a79b924524b1e7fffe304517b2bff5a58bf64f30b98bbc5079eb", size = 147889, upload_time = "2025-10-14T04:41:34.897Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/10/bf/979224a919a1b606c82bd2c5fa49b5c6d5727aa47b4312bb27b1734f53cd/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74664978bb272435107de04e36db5a9735e78232b85b77d45cfb38f758efd33e", size = 143641, upload_time = "2025-10-14T04:41:36.116Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ba/33/0ad65587441fc730dc7bd90e9716b30b4702dc7b617e6ba4997dc8651495/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:752944c7ffbfdd10c074dc58ec2d5a8a4cd9493b314d367c14d24c17684ddd14", size = 160779, upload_time = "2025-10-14T04:41:37.229Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/67/ed/331d6b249259ee71ddea93f6f2f0a56cfebd46938bde6fcc6f7b9a3d0e09/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1f13550535ad8cff21b8d757a3257963e951d96e20ec82ab44bc64aeb62a191", size = 159035, upload_time = "2025-10-14T04:41:38.368Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/67/ff/f6b948ca32e4f2a4576aa129d8bed61f2e0543bf9f5f2b7fc3758ed005c9/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ecaae4149d99b1c9e7b88bb03e3221956f68fd6d50be2ef061b2381b61d20838", size = 152542, upload_time = "2025-10-14T04:41:39.862Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/16/85/276033dcbcc369eb176594de22728541a925b2632f9716428c851b149e83/charset_normalizer-3.4.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cb6254dc36b47a990e59e1068afacdcd02958bdcce30bb50cc1700a8b9d624a6", size = 149524, upload_time = "2025-10-14T04:41:41.319Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/9e/f2/6a2a1f722b6aba37050e626530a46a68f74e63683947a8acff92569f979a/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c8ae8a0f02f57a6e61203a31428fa1d677cbe50c93622b4149d5c0f319c1d19e", size = 150395, upload_time = "2025-10-14T04:41:42.539Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/60/bb/2186cb2f2bbaea6338cad15ce23a67f9b0672929744381e28b0592676824/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:47cc91b2f4dd2833fddaedd2893006b0106129d4b94fdb6af1f4ce5a9965577c", size = 143680, upload_time = "2025-10-14T04:41:43.661Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/7d/a5/bf6f13b772fbb2a90360eb620d52ed8f796f3c5caee8398c3b2eb7b1c60d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:82004af6c302b5d3ab2cfc4cc5f29db16123b1a8417f2e25f9066f91d4411090", size = 162045, upload_time = "2025-10-14T04:41:44.821Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/df/c5/d1be898bf0dc3ef9030c3825e5d3b83f2c528d207d246cbabe245966808d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b7d8f6c26245217bd2ad053761201e9f9680f8ce52f0fcd8d0755aeae5b2152", size = 149687, upload_time = "2025-10-14T04:41:46.442Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a5/42/90c1f7b9341eef50c8a1cb3f098ac43b0508413f33affd762855f67a410e/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:799a7a5e4fb2d5898c60b640fd4981d6a25f1c11790935a44ce38c54e985f828", size = 160014, upload_time = "2025-10-14T04:41:47.631Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/76/be/4d3ee471e8145d12795ab655ece37baed0929462a86e72372fd25859047c/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:99ae2cffebb06e6c22bdc25801d7b30f503cc87dbd283479e7b606f70aff57ec", size = 154044, upload_time = "2025-10-14T04:41:48.81Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b0/6f/8f7af07237c34a1defe7defc565a9bc1807762f672c0fde711a4b22bf9c0/charset_normalizer-3.4.4-cp314-cp314-win32.whl", hash = "sha256:f9d332f8c2a2fcbffe1378594431458ddbef721c1769d78e2cbc06280d8155f9", size = 99940, upload_time = "2025-10-14T04:41:49.946Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/4b/51/8ade005e5ca5b0d80fb4aff72a3775b325bdc3d27408c8113811a7cbe640/charset_normalizer-3.4.4-cp314-cp314-win_amd64.whl", hash = "sha256:8a6562c3700cce886c5be75ade4a5db4214fda19fede41d9792d100288d8f94c", size = 107104, upload_time = "2025-10-14T04:41:51.051Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/da/5f/6b8f83a55bb8278772c5ae54a577f3099025f9ade59d0136ac24a0df4bde/charset_normalizer-3.4.4-cp314-cp314-win_arm64.whl", hash = "sha256:de00632ca48df9daf77a2c65a484531649261ec9f25489917f09e455cb09ddb2", size = 100743, upload_time = "2025-10-14T04:41:52.122Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0a/4c/925909008ed5a988ccbb72dcc897407e5d6d3bd72410d69e051fc0c14647/charset_normalizer-3.4.4-py3-none-any.whl", hash = "sha256:7a32c560861a02ff789ad905a2fe94e3f840803362c84fecf1851cb4cf3dc37f", size = 53402, upload_time = "2025-10-14T04:42:31.76Z" }, +] + +[[package]] +name = "click" +version = "8.3.1" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3d/fa/656b739db8587d7b5dfa22e22ed02566950fbfbcdc20311993483657a5c0/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", size = 295065, upload_time = "2025-11-15T20:45:42.706Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274, upload_time = "2025-11-15T20:45:41.139Z" }, +] + +[[package]] +name = "colorama" +version = "0.4.6" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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.tuna.tsinghua.edu.cn/simple" } +resolution-markers = [ + "python_full_version < '3.11'", +] +dependencies = [ + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }, marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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 = "contourpy" +version = "1.3.3" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", +] +dependencies = [ + { name = "numpy", version = "2.3.5", source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }, marker = "python_full_version >= '3.11'" }, +] +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/58/01/1253e6698a07380cd31a736d248a3f2a50a7c88779a1813da27503cadc2a/contourpy-1.3.3.tar.gz", hash = "sha256:083e12155b210502d0bca491432bb04d56dc3432f95a979b429f2848c3dbe880", size = 13466174, upload_time = "2025-07-26T12:03:12.549Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/91/2e/c4390a31919d8a78b90e8ecf87cd4b4c4f05a5b48d05ec17db8e5404c6f4/contourpy-1.3.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:709a48ef9a690e1343202916450bc48b9e51c049b089c7f79a267b46cffcdaa1", size = 288773, upload_time = "2025-07-26T12:01:02.277Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0d/44/c4b0b6095fef4dc9c420e041799591e3b63e9619e3044f7f4f6c21c0ab24/contourpy-1.3.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:23416f38bfd74d5d28ab8429cc4d63fa67d5068bd711a85edb1c3fb0c3e2f381", size = 270149, upload_time = "2025-07-26T12:01:04.072Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/30/2e/dd4ced42fefac8470661d7cb7e264808425e6c5d56d175291e93890cce09/contourpy-1.3.3-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:929ddf8c4c7f348e4c0a5a3a714b5c8542ffaa8c22954862a46ca1813b667ee7", size = 329222, upload_time = "2025-07-26T12:01:05.688Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f2/74/cc6ec2548e3d276c71389ea4802a774b7aa3558223b7bade3f25787fafc2/contourpy-1.3.3-cp311-cp311-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9e999574eddae35f1312c2b4b717b7885d4edd6cb46700e04f7f02db454e67c1", size = 377234, upload_time = "2025-07-26T12:01:07.054Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/03/b3/64ef723029f917410f75c09da54254c5f9ea90ef89b143ccadb09df14c15/contourpy-1.3.3-cp311-cp311-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0bf67e0e3f482cb69779dd3061b534eb35ac9b17f163d851e2a547d56dba0a3a", size = 380555, upload_time = "2025-07-26T12:01:08.801Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5f/4b/6157f24ca425b89fe2eb7e7be642375711ab671135be21e6faa100f7448c/contourpy-1.3.3-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:51e79c1f7470158e838808d4a996fa9bac72c498e93d8ebe5119bc1e6becb0db", size = 355238, upload_time = "2025-07-26T12:01:10.319Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/98/56/f914f0dd678480708a04cfd2206e7c382533249bc5001eb9f58aa693e200/contourpy-1.3.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:598c3aaece21c503615fd59c92a3598b428b2f01bfb4b8ca9c4edeecc2438620", size = 1326218, upload_time = "2025-07-26T12:01:12.659Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fb/d7/4a972334a0c971acd5172389671113ae82aa7527073980c38d5868ff1161/contourpy-1.3.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:322ab1c99b008dad206d406bb61d014cf0174df491ae9d9d0fac6a6fda4f977f", size = 1392867, upload_time = "2025-07-26T12:01:15.533Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/75/3e/f2cc6cd56dc8cff46b1a56232eabc6feea52720083ea71ab15523daab796/contourpy-1.3.3-cp311-cp311-win32.whl", hash = "sha256:fd907ae12cd483cd83e414b12941c632a969171bf90fc937d0c9f268a31cafff", size = 183677, upload_time = "2025-07-26T12:01:17.088Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/98/4b/9bd370b004b5c9d8045c6c33cf65bae018b27aca550a3f657cdc99acdbd8/contourpy-1.3.3-cp311-cp311-win_amd64.whl", hash = "sha256:3519428f6be58431c56581f1694ba8e50626f2dd550af225f82fb5f5814d2a42", size = 225234, upload_time = "2025-07-26T12:01:18.256Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d9/b6/71771e02c2e004450c12b1120a5f488cad2e4d5b590b1af8bad060360fe4/contourpy-1.3.3-cp311-cp311-win_arm64.whl", hash = "sha256:15ff10bfada4bf92ec8b31c62bf7c1834c244019b4a33095a68000d7075df470", size = 193123, upload_time = "2025-07-26T12:01:19.848Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/be/45/adfee365d9ea3d853550b2e735f9d66366701c65db7855cd07621732ccfc/contourpy-1.3.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b08a32ea2f8e42cf1d4be3169a98dd4be32bafe4f22b6c4cb4ba810fa9e5d2cb", size = 293419, upload_time = "2025-07-26T12:01:21.16Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/53/3e/405b59cfa13021a56bba395a6b3aca8cec012b45bf177b0eaf7a202cde2c/contourpy-1.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:556dba8fb6f5d8742f2923fe9457dbdd51e1049c4a43fd3986a0b14a1d815fc6", size = 273979, upload_time = "2025-07-26T12:01:22.448Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d4/1c/a12359b9b2ca3a845e8f7f9ac08bdf776114eb931392fcad91743e2ea17b/contourpy-1.3.3-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92d9abc807cf7d0e047b95ca5d957cf4792fcd04e920ca70d48add15c1a90ea7", size = 332653, upload_time = "2025-07-26T12:01:24.155Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/63/12/897aeebfb475b7748ea67b61e045accdfcf0d971f8a588b67108ed7f5512/contourpy-1.3.3-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b2e8faa0ed68cb29af51edd8e24798bb661eac3bd9f65420c1887b6ca89987c8", size = 379536, upload_time = "2025-07-26T12:01:25.91Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/43/8a/a8c584b82deb248930ce069e71576fc09bd7174bbd35183b7943fb1064fd/contourpy-1.3.3-cp312-cp312-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:626d60935cf668e70a5ce6ff184fd713e9683fb458898e4249b63be9e28286ea", size = 384397, upload_time = "2025-07-26T12:01:27.152Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/cc/8f/ec6289987824b29529d0dfda0d74a07cec60e54b9c92f3c9da4c0ac732de/contourpy-1.3.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4d00e655fcef08aba35ec9610536bfe90267d7ab5ba944f7032549c55a146da1", size = 362601, upload_time = "2025-07-26T12:01:28.808Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/05/0a/a3fe3be3ee2dceb3e615ebb4df97ae6f3828aa915d3e10549ce016302bd1/contourpy-1.3.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:451e71b5a7d597379ef572de31eeb909a87246974d960049a9848c3bc6c41bf7", size = 1331288, upload_time = "2025-07-26T12:01:31.198Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/33/1d/acad9bd4e97f13f3e2b18a3977fe1b4a37ecf3d38d815333980c6c72e963/contourpy-1.3.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:459c1f020cd59fcfe6650180678a9993932d80d44ccde1fa1868977438f0b411", size = 1403386, upload_time = "2025-07-26T12:01:33.947Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/cf/8f/5847f44a7fddf859704217a99a23a4f6417b10e5ab1256a179264561540e/contourpy-1.3.3-cp312-cp312-win32.whl", hash = "sha256:023b44101dfe49d7d53932be418477dba359649246075c996866106da069af69", size = 185018, upload_time = "2025-07-26T12:01:35.64Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/19/e8/6026ed58a64563186a9ee3f29f41261fd1828f527dd93d33b60feca63352/contourpy-1.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:8153b8bfc11e1e4d75bcb0bff1db232f9e10b274e0929de9d608027e0d34ff8b", size = 226567, upload_time = "2025-07-26T12:01:36.804Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d1/e2/f05240d2c39a1ed228d8328a78b6f44cd695f7ef47beb3e684cf93604f86/contourpy-1.3.3-cp312-cp312-win_arm64.whl", hash = "sha256:07ce5ed73ecdc4a03ffe3e1b3e3c1166db35ae7584be76f65dbbe28a7791b0cc", size = 193655, upload_time = "2025-07-26T12:01:37.999Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/68/35/0167aad910bbdb9599272bd96d01a9ec6852f36b9455cf2ca67bd4cc2d23/contourpy-1.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:177fb367556747a686509d6fef71d221a4b198a3905fe824430e5ea0fda54eb5", size = 293257, upload_time = "2025-07-26T12:01:39.367Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/96/e4/7adcd9c8362745b2210728f209bfbcf7d91ba868a2c5f40d8b58f54c509b/contourpy-1.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d002b6f00d73d69333dac9d0b8d5e84d9724ff9ef044fd63c5986e62b7c9e1b1", size = 274034, upload_time = "2025-07-26T12:01:40.645Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/73/23/90e31ceeed1de63058a02cb04b12f2de4b40e3bef5e082a7c18d9c8ae281/contourpy-1.3.3-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:348ac1f5d4f1d66d3322420f01d42e43122f43616e0f194fc1c9f5d830c5b286", size = 334672, upload_time = "2025-07-26T12:01:41.942Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ed/93/b43d8acbe67392e659e1d984700e79eb67e2acb2bd7f62012b583a7f1b55/contourpy-1.3.3-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:655456777ff65c2c548b7c454af9c6f33f16c8884f11083244b5819cc214f1b5", size = 381234, upload_time = "2025-07-26T12:01:43.499Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/46/3b/bec82a3ea06f66711520f75a40c8fc0b113b2a75edb36aa633eb11c4f50f/contourpy-1.3.3-cp313-cp313-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:644a6853d15b2512d67881586bd03f462c7ab755db95f16f14d7e238f2852c67", size = 385169, upload_time = "2025-07-26T12:01:45.219Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/4b/32/e0f13a1c5b0f8572d0ec6ae2f6c677b7991fafd95da523159c19eff0696a/contourpy-1.3.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4debd64f124ca62069f313a9cb86656ff087786016d76927ae2cf37846b006c9", size = 362859, upload_time = "2025-07-26T12:01:46.519Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/33/71/e2a7945b7de4e58af42d708a219f3b2f4cff7386e6b6ab0a0fa0033c49a9/contourpy-1.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a15459b0f4615b00bbd1e91f1b9e19b7e63aea7483d03d804186f278c0af2659", size = 1332062, upload_time = "2025-07-26T12:01:48.964Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/12/fc/4e87ac754220ccc0e807284f88e943d6d43b43843614f0a8afa469801db0/contourpy-1.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ca0fdcd73925568ca027e0b17ab07aad764be4706d0a925b89227e447d9737b7", size = 1403932, upload_time = "2025-07-26T12:01:51.979Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a6/2e/adc197a37443f934594112222ac1aa7dc9a98faf9c3842884df9a9d8751d/contourpy-1.3.3-cp313-cp313-win32.whl", hash = "sha256:b20c7c9a3bf701366556e1b1984ed2d0cedf999903c51311417cf5f591d8c78d", size = 185024, upload_time = "2025-07-26T12:01:53.245Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/18/0b/0098c214843213759692cc638fce7de5c289200a830e5035d1791d7a2338/contourpy-1.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:1cadd8b8969f060ba45ed7c1b714fe69185812ab43bd6b86a9123fe8f99c3263", size = 226578, upload_time = "2025-07-26T12:01:54.422Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8a/9a/2f6024a0c5995243cd63afdeb3651c984f0d2bc727fd98066d40e141ad73/contourpy-1.3.3-cp313-cp313-win_arm64.whl", hash = "sha256:fd914713266421b7536de2bfa8181aa8c699432b6763a0ea64195ebe28bff6a9", size = 193524, upload_time = "2025-07-26T12:01:55.73Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c0/b3/f8a1a86bd3298513f500e5b1f5fd92b69896449f6cab6a146a5d52715479/contourpy-1.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:88df9880d507169449d434c293467418b9f6cbe82edd19284aa0409e7fdb933d", size = 306730, upload_time = "2025-07-26T12:01:57.051Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3f/11/4780db94ae62fc0c2053909b65dc3246bd7cecfc4f8a20d957ad43aa4ad8/contourpy-1.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:d06bb1f751ba5d417047db62bca3c8fde202b8c11fb50742ab3ab962c81e8216", size = 287897, upload_time = "2025-07-26T12:01:58.663Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ae/15/e59f5f3ffdd6f3d4daa3e47114c53daabcb18574a26c21f03dc9e4e42ff0/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e4e6b05a45525357e382909a4c1600444e2a45b4795163d3b22669285591c1ae", size = 326751, upload_time = "2025-07-26T12:02:00.343Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0f/81/03b45cfad088e4770b1dcf72ea78d3802d04200009fb364d18a493857210/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ab3074b48c4e2cf1a960e6bbeb7f04566bf36b1861d5c9d4d8ac04b82e38ba20", size = 375486, upload_time = "2025-07-26T12:02:02.128Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0c/ba/49923366492ffbdd4486e970d421b289a670ae8cf539c1ea9a09822b371a/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6c3d53c796f8647d6deb1abe867daeb66dcc8a97e8455efa729516b997b8ed99", size = 388106, upload_time = "2025-07-26T12:02:03.615Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/9f/52/5b00ea89525f8f143651f9f03a0df371d3cbd2fccd21ca9b768c7a6500c2/contourpy-1.3.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50ed930df7289ff2a8d7afeb9603f8289e5704755c7e5c3bbd929c90c817164b", size = 352548, upload_time = "2025-07-26T12:02:05.165Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/32/1d/a209ec1a3a3452d490f6b14dd92e72280c99ae3d1e73da74f8277d4ee08f/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4feffb6537d64b84877da813a5c30f1422ea5739566abf0bd18065ac040e120a", size = 1322297, upload_time = "2025-07-26T12:02:07.379Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/bc/9e/46f0e8ebdd884ca0e8877e46a3f4e633f6c9c8c4f3f6e72be3fe075994aa/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:2b7e9480ffe2b0cd2e787e4df64270e3a0440d9db8dc823312e2c940c167df7e", size = 1391023, upload_time = "2025-07-26T12:02:10.171Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b9/70/f308384a3ae9cd2209e0849f33c913f658d3326900d0ff5d378d6a1422d2/contourpy-1.3.3-cp313-cp313t-win32.whl", hash = "sha256:283edd842a01e3dcd435b1c5116798d661378d83d36d337b8dde1d16a5fc9ba3", size = 196157, upload_time = "2025-07-26T12:02:11.488Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b2/dd/880f890a6663b84d9e34a6f88cded89d78f0091e0045a284427cb6b18521/contourpy-1.3.3-cp313-cp313t-win_amd64.whl", hash = "sha256:87acf5963fc2b34825e5b6b048f40e3635dd547f590b04d2ab317c2619ef7ae8", size = 240570, upload_time = "2025-07-26T12:02:12.754Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/80/99/2adc7d8ffead633234817ef8e9a87115c8a11927a94478f6bb3d3f4d4f7d/contourpy-1.3.3-cp313-cp313t-win_arm64.whl", hash = "sha256:3c30273eb2a55024ff31ba7d052dde990d7d8e5450f4bbb6e913558b3d6c2301", size = 199713, upload_time = "2025-07-26T12:02:14.4Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/72/8b/4546f3ab60f78c514ffb7d01a0bd743f90de36f0019d1be84d0a708a580a/contourpy-1.3.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fde6c716d51c04b1c25d0b90364d0be954624a0ee9d60e23e850e8d48353d07a", size = 292189, upload_time = "2025-07-26T12:02:16.095Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fd/e1/3542a9cb596cadd76fcef413f19c79216e002623158befe6daa03dbfa88c/contourpy-1.3.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:cbedb772ed74ff5be440fa8eee9bd49f64f6e3fc09436d9c7d8f1c287b121d77", size = 273251, upload_time = "2025-07-26T12:02:17.524Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b1/71/f93e1e9471d189f79d0ce2497007731c1e6bf9ef6d1d61b911430c3db4e5/contourpy-1.3.3-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:22e9b1bd7a9b1d652cd77388465dc358dafcd2e217d35552424aa4f996f524f5", size = 335810, upload_time = "2025-07-26T12:02:18.9Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/91/f9/e35f4c1c93f9275d4e38681a80506b5510e9327350c51f8d4a5a724d178c/contourpy-1.3.3-cp314-cp314-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a22738912262aa3e254e4f3cb079a95a67132fc5a063890e224393596902f5a4", size = 382871, upload_time = "2025-07-26T12:02:20.418Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b5/71/47b512f936f66a0a900d81c396a7e60d73419868fba959c61efed7a8ab46/contourpy-1.3.3-cp314-cp314-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:afe5a512f31ee6bd7d0dda52ec9864c984ca3d66664444f2d72e0dc4eb832e36", size = 386264, upload_time = "2025-07-26T12:02:21.916Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/04/5f/9ff93450ba96b09c7c2b3f81c94de31c89f92292f1380261bd7195bea4ea/contourpy-1.3.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f64836de09927cba6f79dcd00fdd7d5329f3fccc633468507079c829ca4db4e3", size = 363819, upload_time = "2025-07-26T12:02:23.759Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3e/a6/0b185d4cc480ee494945cde102cb0149ae830b5fa17bf855b95f2e70ad13/contourpy-1.3.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:1fd43c3be4c8e5fd6e4f2baeae35ae18176cf2e5cced681cca908addf1cdd53b", size = 1333650, upload_time = "2025-07-26T12:02:26.181Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/43/d7/afdc95580ca56f30fbcd3060250f66cedbde69b4547028863abd8aa3b47e/contourpy-1.3.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6afc576f7b33cf00996e5c1102dc2a8f7cc89e39c0b55df93a0b78c1bd992b36", size = 1404833, upload_time = "2025-07-26T12:02:28.782Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e2/e2/366af18a6d386f41132a48f033cbd2102e9b0cf6345d35ff0826cd984566/contourpy-1.3.3-cp314-cp314-win32.whl", hash = "sha256:66c8a43a4f7b8df8b71ee1840e4211a3c8d93b214b213f590e18a1beca458f7d", size = 189692, upload_time = "2025-07-26T12:02:30.128Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/7d/c2/57f54b03d0f22d4044b8afb9ca0e184f8b1afd57b4f735c2fa70883dc601/contourpy-1.3.3-cp314-cp314-win_amd64.whl", hash = "sha256:cf9022ef053f2694e31d630feaacb21ea24224be1c3ad0520b13d844274614fd", size = 232424, upload_time = "2025-07-26T12:02:31.395Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/18/79/a9416650df9b525737ab521aa181ccc42d56016d2123ddcb7b58e926a42c/contourpy-1.3.3-cp314-cp314-win_arm64.whl", hash = "sha256:95b181891b4c71de4bb404c6621e7e2390745f887f2a026b2d99e92c17892339", size = 198300, upload_time = "2025-07-26T12:02:32.956Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/1f/42/38c159a7d0f2b7b9c04c64ab317042bb6952b713ba875c1681529a2932fe/contourpy-1.3.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:33c82d0138c0a062380332c861387650c82e4cf1747aaa6938b9b6516762e772", size = 306769, upload_time = "2025-07-26T12:02:34.2Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c3/6c/26a8205f24bca10974e77460de68d3d7c63e282e23782f1239f226fcae6f/contourpy-1.3.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ea37e7b45949df430fe649e5de8351c423430046a2af20b1c1961cae3afcda77", size = 287892, upload_time = "2025-07-26T12:02:35.807Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/66/06/8a475c8ab718ebfd7925661747dbb3c3ee9c82ac834ccb3570be49d129f4/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d304906ecc71672e9c89e87c4675dc5c2645e1f4269a5063b99b0bb29f232d13", size = 326748, upload_time = "2025-07-26T12:02:37.193Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b4/a3/c5ca9f010a44c223f098fccd8b158bb1cb287378a31ac141f04730dc49be/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ca658cd1a680a5c9ea96dc61cdbae1e85c8f25849843aa799dfd3cb370ad4fbe", size = 375554, upload_time = "2025-07-26T12:02:38.894Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/80/5b/68bd33ae63fac658a4145088c1e894405e07584a316738710b636c6d0333/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ab2fd90904c503739a75b7c8c5c01160130ba67944a7b77bbf36ef8054576e7f", size = 388118, upload_time = "2025-07-26T12:02:40.642Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/40/52/4c285a6435940ae25d7410a6c36bda5145839bc3f0beb20c707cda18b9d2/contourpy-1.3.3-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b7301b89040075c30e5768810bc96a8e8d78085b47d8be6e4c3f5a0b4ed478a0", size = 352555, upload_time = "2025-07-26T12:02:42.25Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/24/ee/3e81e1dd174f5c7fefe50e85d0892de05ca4e26ef1c9a59c2a57e43b865a/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:2a2a8b627d5cc6b7c41a4beff6c5ad5eb848c88255fda4a8745f7e901b32d8e4", size = 1322295, upload_time = "2025-07-26T12:02:44.668Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3c/b2/6d913d4d04e14379de429057cd169e5e00f6c2af3bb13e1710bcbdb5da12/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:fd6ec6be509c787f1caf6b247f0b1ca598bef13f4ddeaa126b7658215529ba0f", size = 1391027, upload_time = "2025-07-26T12:02:47.09Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/93/8a/68a4ec5c55a2971213d29a9374913f7e9f18581945a7a31d1a39b5d2dfe5/contourpy-1.3.3-cp314-cp314t-win32.whl", hash = "sha256:e74a9a0f5e3fff48fb5a7f2fd2b9b70a3fe014a67522f79b7cca4c0c7e43c9ae", size = 202428, upload_time = "2025-07-26T12:02:48.691Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fa/96/fd9f641ffedc4fa3ace923af73b9d07e869496c9cc7a459103e6e978992f/contourpy-1.3.3-cp314-cp314t-win_amd64.whl", hash = "sha256:13b68d6a62db8eafaebb8039218921399baf6e47bf85006fd8529f2a08ef33fc", size = 250331, upload_time = "2025-07-26T12:02:50.137Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ae/8c/469afb6465b853afff216f9528ffda78a915ff880ed58813ba4faf4ba0b6/contourpy-1.3.3-cp314-cp314t-win_arm64.whl", hash = "sha256:b7448cb5a725bb1e35ce88771b86fba35ef418952474492cf7c764059933ff8b", size = 203831, upload_time = "2025-07-26T12:02:51.449Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a5/29/8dcfe16f0107943fa92388c23f6e05cff0ba58058c4c95b00280d4c75a14/contourpy-1.3.3-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:cd5dfcaeb10f7b7f9dc8941717c6c2ade08f587be2226222c12b25f0483ed497", size = 278809, upload_time = "2025-07-26T12:02:52.74Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/85/a9/8b37ef4f7dafeb335daee3c8254645ef5725be4d9c6aa70b50ec46ef2f7e/contourpy-1.3.3-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:0c1fc238306b35f246d61a1d416a627348b5cf0648648a031e14bb8705fcdfe8", size = 261593, upload_time = "2025-07-26T12:02:54.037Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0a/59/ebfb8c677c75605cc27f7122c90313fd2f375ff3c8d19a1694bda74aaa63/contourpy-1.3.3-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:70f9aad7de812d6541d29d2bbf8feb22ff7e1c299523db288004e3157ff4674e", size = 302202, upload_time = "2025-07-26T12:02:55.947Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3c/37/21972a15834d90bfbfb009b9d004779bd5a07a0ec0234e5ba8f64d5736f4/contourpy-1.3.3-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5ed3657edf08512fc3fe81b510e35c2012fbd3081d2e26160f27ca28affec989", size = 329207, upload_time = "2025-07-26T12:02:57.468Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0c/58/bd257695f39d05594ca4ad60df5bcb7e32247f9951fd09a9b8edb82d1daa/contourpy-1.3.3-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:3d1a3799d62d45c18bafd41c5fa05120b96a28079f2393af559b843d1a966a77", size = 225315, upload_time = "2025-07-26T12:02:58.801Z" }, +] + +[[package]] +name = "cryptography" +version = "46.0.3" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +dependencies = [ + { name = "cffi", marker = "platform_python_implementation != 'PyPy'" }, + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/9f/33/c00162f49c0e2fe8064a62cb92b93e50c74a72bc370ab92f86112b33ff62/cryptography-46.0.3.tar.gz", hash = "sha256:a8b17438104fed022ce745b362294d9ce35b4c2e45c1d958ad4a4b019285f4a1", size = 749258, upload_time = "2025-10-15T23:18:31.74Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/1d/42/9c391dd801d6cf0d561b5890549d4b27bafcc53b39c31a817e69d87c625b/cryptography-46.0.3-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:109d4ddfadf17e8e7779c39f9b18111a09efb969a301a31e987416a0191ed93a", size = 7225004, upload_time = "2025-10-15T23:16:52.239Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/1c/67/38769ca6b65f07461eb200e85fc1639b438bdc667be02cf7f2cd6a64601c/cryptography-46.0.3-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:09859af8466b69bc3c27bdf4f5d84a665e0f7ab5088412e9e2ec49758eca5cbc", size = 4296667, upload_time = "2025-10-15T23:16:54.369Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5c/49/498c86566a1d80e978b42f0d702795f69887005548c041636df6ae1ca64c/cryptography-46.0.3-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:01ca9ff2885f3acc98c29f1860552e37f6d7c7d013d7334ff2a9de43a449315d", size = 4450807, upload_time = "2025-10-15T23:16:56.414Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/4b/0a/863a3604112174c8624a2ac3c038662d9e59970c7f926acdcfaed8d61142/cryptography-46.0.3-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:6eae65d4c3d33da080cff9c4ab1f711b15c1d9760809dad6ea763f3812d254cb", size = 4299615, upload_time = "2025-10-15T23:16:58.442Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/64/02/b73a533f6b64a69f3cd3872acb6ebc12aef924d8d103133bb3ea750dc703/cryptography-46.0.3-cp311-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e5bf0ed4490068a2e72ac03d786693adeb909981cc596425d09032d372bcc849", size = 4016800, upload_time = "2025-10-15T23:17:00.378Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/25/d5/16e41afbfa450cde85a3b7ec599bebefaef16b5c6ba4ec49a3532336ed72/cryptography-46.0.3-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:5ecfccd2329e37e9b7112a888e76d9feca2347f12f37918facbb893d7bb88ee8", size = 4984707, upload_time = "2025-10-15T23:17:01.98Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c9/56/e7e69b427c3878352c2fb9b450bd0e19ed552753491d39d7d0a2f5226d41/cryptography-46.0.3-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:a2c0cd47381a3229c403062f764160d57d4d175e022c1df84e168c6251a22eec", size = 4482541, upload_time = "2025-10-15T23:17:04.078Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/78/f6/50736d40d97e8483172f1bb6e698895b92a223dba513b0ca6f06b2365339/cryptography-46.0.3-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:549e234ff32571b1f4076ac269fcce7a808d3bf98b76c8dd560e42dbc66d7d91", size = 4299464, upload_time = "2025-10-15T23:17:05.483Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/00/de/d8e26b1a855f19d9994a19c702fa2e93b0456beccbcfe437eda00e0701f2/cryptography-46.0.3-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:c0a7bb1a68a5d3471880e264621346c48665b3bf1c3759d682fc0864c540bd9e", size = 4950838, upload_time = "2025-10-15T23:17:07.425Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8f/29/798fc4ec461a1c9e9f735f2fc58741b0daae30688f41b2497dcbc9ed1355/cryptography-46.0.3-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:10b01676fc208c3e6feeb25a8b83d81767e8059e1fe86e1dc62d10a3018fa926", size = 4481596, upload_time = "2025-10-15T23:17:09.343Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/15/8d/03cd48b20a573adfff7652b76271078e3045b9f49387920e7f1f631d125e/cryptography-46.0.3-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0abf1ffd6e57c67e92af68330d05760b7b7efb243aab8377e583284dbab72c71", size = 4426782, upload_time = "2025-10-15T23:17:11.22Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fa/b1/ebacbfe53317d55cf33165bda24c86523497a6881f339f9aae5c2e13e57b/cryptography-46.0.3-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a04bee9ab6a4da801eb9b51f1b708a1b5b5c9eb48c03f74198464c66f0d344ac", size = 4698381, upload_time = "2025-10-15T23:17:12.829Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/96/92/8a6a9525893325fc057a01f654d7efc2c64b9de90413adcf605a85744ff4/cryptography-46.0.3-cp311-abi3-win32.whl", hash = "sha256:f260d0d41e9b4da1ed1e0f1ce571f97fe370b152ab18778e9e8f67d6af432018", size = 3055988, upload_time = "2025-10-15T23:17:14.65Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/7e/bf/80fbf45253ea585a1e492a6a17efcb93467701fa79e71550a430c5e60df0/cryptography-46.0.3-cp311-abi3-win_amd64.whl", hash = "sha256:a9a3008438615669153eb86b26b61e09993921ebdd75385ddd748702c5adfddb", size = 3514451, upload_time = "2025-10-15T23:17:16.142Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2e/af/9b302da4c87b0beb9db4e756386a7c6c5b8003cd0e742277888d352ae91d/cryptography-46.0.3-cp311-abi3-win_arm64.whl", hash = "sha256:5d7f93296ee28f68447397bf5198428c9aeeab45705a55d53a6343455dcb2c3c", size = 2928007, upload_time = "2025-10-15T23:17:18.04Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f5/e2/a510aa736755bffa9d2f75029c229111a1d02f8ecd5de03078f4c18d91a3/cryptography-46.0.3-cp314-cp314t-macosx_10_9_universal2.whl", hash = "sha256:00a5e7e87938e5ff9ff5447ab086a5706a957137e6e433841e9d24f38a065217", size = 7158012, upload_time = "2025-10-15T23:17:19.982Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/73/dc/9aa866fbdbb95b02e7f9d086f1fccfeebf8953509b87e3f28fff927ff8a0/cryptography-46.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c8daeb2d2174beb4575b77482320303f3d39b8e81153da4f0fb08eb5fe86a6c5", size = 4288728, upload_time = "2025-10-15T23:17:21.527Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c5/fd/bc1daf8230eaa075184cbbf5f8cd00ba9db4fd32d63fb83da4671b72ed8a/cryptography-46.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:39b6755623145ad5eff1dab323f4eae2a32a77a7abef2c5089a04a3d04366715", size = 4435078, upload_time = "2025-10-15T23:17:23.042Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/82/98/d3bd5407ce4c60017f8ff9e63ffee4200ab3e23fe05b765cab805a7db008/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:db391fa7c66df6762ee3f00c95a89e6d428f4d60e7abc8328f4fe155b5ac6e54", size = 4293460, upload_time = "2025-10-15T23:17:24.885Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/26/e9/e23e7900983c2b8af7a08098db406cf989d7f09caea7897e347598d4cd5b/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:78a97cf6a8839a48c49271cdcbd5cf37ca2c1d6b7fdd86cc864f302b5e9bf459", size = 3995237, upload_time = "2025-10-15T23:17:26.449Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/91/15/af68c509d4a138cfe299d0d7ddb14afba15233223ebd933b4bbdbc7155d3/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:dfb781ff7eaa91a6f7fd41776ec37c5853c795d3b358d4896fdbb5df168af422", size = 4967344, upload_time = "2025-10-15T23:17:28.06Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ca/e3/8643d077c53868b681af077edf6b3cb58288b5423610f21c62aadcbe99f4/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:6f61efb26e76c45c4a227835ddeae96d83624fb0d29eb5df5b96e14ed1a0afb7", size = 4466564, upload_time = "2025-10-15T23:17:29.665Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0e/43/c1e8726fa59c236ff477ff2b5dc071e54b21e5a1e51aa2cee1676f1c986f/cryptography-46.0.3-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:23b1a8f26e43f47ceb6d6a43115f33a5a37d57df4ea0ca295b780ae8546e8044", size = 4292415, upload_time = "2025-10-15T23:17:31.686Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/42/f9/2f8fefdb1aee8a8e3256a0568cffc4e6d517b256a2fe97a029b3f1b9fe7e/cryptography-46.0.3-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:b419ae593c86b87014b9be7396b385491ad7f320bde96826d0dd174459e54665", size = 4931457, upload_time = "2025-10-15T23:17:33.478Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/79/30/9b54127a9a778ccd6d27c3da7563e9f2d341826075ceab89ae3b41bf5be2/cryptography-46.0.3-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:50fc3343ac490c6b08c0cf0d704e881d0d660be923fd3076db3e932007e726e3", size = 4466074, upload_time = "2025-10-15T23:17:35.158Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ac/68/b4f4a10928e26c941b1b6a179143af9f4d27d88fe84a6a3c53592d2e76bf/cryptography-46.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:22d7e97932f511d6b0b04f2bfd818d73dcd5928db509460aaf48384778eb6d20", size = 4420569, upload_time = "2025-10-15T23:17:37.188Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a3/49/3746dab4c0d1979888f125226357d3262a6dd40e114ac29e3d2abdf1ec55/cryptography-46.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d55f3dffadd674514ad19451161118fd010988540cee43d8bc20675e775925de", size = 4681941, upload_time = "2025-10-15T23:17:39.236Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fd/30/27654c1dbaf7e4a3531fa1fc77986d04aefa4d6d78259a62c9dc13d7ad36/cryptography-46.0.3-cp314-cp314t-win32.whl", hash = "sha256:8a6e050cb6164d3f830453754094c086ff2d0b2f3a897a1d9820f6139a1f0914", size = 3022339, upload_time = "2025-10-15T23:17:40.888Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f6/30/640f34ccd4d2a1bc88367b54b926b781b5a018d65f404d409aba76a84b1c/cryptography-46.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:760f83faa07f8b64e9c33fc963d790a2edb24efb479e3520c14a45741cd9b2db", size = 3494315, upload_time = "2025-10-15T23:17:42.769Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ba/8b/88cc7e3bd0a8e7b861f26981f7b820e1f46aa9d26cc482d0feba0ecb4919/cryptography-46.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:516ea134e703e9fe26bcd1277a4b59ad30586ea90c365a87781d7887a646fe21", size = 2919331, upload_time = "2025-10-15T23:17:44.468Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fd/23/45fe7f376a7df8daf6da3556603b36f53475a99ce4faacb6ba2cf3d82021/cryptography-46.0.3-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:cb3d760a6117f621261d662bccc8ef5bc32ca673e037c83fbe565324f5c46936", size = 7218248, upload_time = "2025-10-15T23:17:46.294Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/27/32/b68d27471372737054cbd34c84981f9edbc24fe67ca225d389799614e27f/cryptography-46.0.3-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:4b7387121ac7d15e550f5cb4a43aef2559ed759c35df7336c402bb8275ac9683", size = 4294089, upload_time = "2025-10-15T23:17:48.269Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/26/42/fa8389d4478368743e24e61eea78846a0006caffaf72ea24a15159215a14/cryptography-46.0.3-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:15ab9b093e8f09daab0f2159bb7e47532596075139dd74365da52ecc9cb46c5d", size = 4440029, upload_time = "2025-10-15T23:17:49.837Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5f/eb/f483db0ec5ac040824f269e93dd2bd8a21ecd1027e77ad7bdf6914f2fd80/cryptography-46.0.3-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:46acf53b40ea38f9c6c229599a4a13f0d46a6c3fa9ef19fc1a124d62e338dfa0", size = 4297222, upload_time = "2025-10-15T23:17:51.357Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fd/cf/da9502c4e1912cb1da3807ea3618a6829bee8207456fbbeebc361ec38ba3/cryptography-46.0.3-cp38-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:10ca84c4668d066a9878890047f03546f3ae0a6b8b39b697457b7757aaf18dbc", size = 4012280, upload_time = "2025-10-15T23:17:52.964Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6b/8f/9adb86b93330e0df8b3dcf03eae67c33ba89958fc2e03862ef1ac2b42465/cryptography-46.0.3-cp38-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:36e627112085bb3b81b19fed209c05ce2a52ee8b15d161b7c643a7d5a88491f3", size = 4978958, upload_time = "2025-10-15T23:17:54.965Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d1/a0/5fa77988289c34bdb9f913f5606ecc9ada1adb5ae870bd0d1054a7021cc4/cryptography-46.0.3-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:1000713389b75c449a6e979ffc7dcc8ac90b437048766cef052d4d30b8220971", size = 4473714, upload_time = "2025-10-15T23:17:56.754Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/14/e5/fc82d72a58d41c393697aa18c9abe5ae1214ff6f2a5c18ac470f92777895/cryptography-46.0.3-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:b02cf04496f6576afffef5ddd04a0cb7d49cf6be16a9059d793a30b035f6b6ac", size = 4296970, upload_time = "2025-10-15T23:17:58.588Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/78/06/5663ed35438d0b09056973994f1aec467492b33bd31da36e468b01ec1097/cryptography-46.0.3-cp38-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:71e842ec9bc7abf543b47cf86b9a743baa95f4677d22baa4c7d5c69e49e9bc04", size = 4940236, upload_time = "2025-10-15T23:18:00.897Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fc/59/873633f3f2dcd8a053b8dd1d38f783043b5fce589c0f6988bf55ef57e43e/cryptography-46.0.3-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:402b58fc32614f00980b66d6e56a5b4118e6cb362ae8f3fda141ba4689bd4506", size = 4472642, upload_time = "2025-10-15T23:18:02.749Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3d/39/8e71f3930e40f6877737d6f69248cf74d4e34b886a3967d32f919cc50d3b/cryptography-46.0.3-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:ef639cb3372f69ec44915fafcd6698b6cc78fbe0c2ea41be867f6ed612811963", size = 4423126, upload_time = "2025-10-15T23:18:04.85Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/cd/c7/f65027c2810e14c3e7268353b1681932b87e5a48e65505d8cc17c99e36ae/cryptography-46.0.3-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:3b51b8ca4f1c6453d8829e1eb7299499ca7f313900dd4d89a24b8b87c0a780d4", size = 4686573, upload_time = "2025-10-15T23:18:06.908Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0a/6e/1c8331ddf91ca4730ab3086a0f1be19c65510a33b5a441cb334e7a2d2560/cryptography-46.0.3-cp38-abi3-win32.whl", hash = "sha256:6276eb85ef938dc035d59b87c8a7dc559a232f954962520137529d77b18ff1df", size = 3036695, upload_time = "2025-10-15T23:18:08.672Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/90/45/b0d691df20633eff80955a0fc7695ff9051ffce8b69741444bd9ed7bd0db/cryptography-46.0.3-cp38-abi3-win_amd64.whl", hash = "sha256:416260257577718c05135c55958b674000baef9a1c7d9e8f306ec60d71db850f", size = 3501720, upload_time = "2025-10-15T23:18:10.632Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e8/cb/2da4cc83f5edb9c3257d09e1e7ab7b23f049c7962cae8d842bbef0a9cec9/cryptography-46.0.3-cp38-abi3-win_arm64.whl", hash = "sha256:d89c3468de4cdc4f08a57e214384d0471911a3830fcdaf7a8cc587e42a866372", size = 2918740, upload_time = "2025-10-15T23:18:12.277Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d9/cd/1a8633802d766a0fa46f382a77e096d7e209e0817892929655fe0586ae32/cryptography-46.0.3-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:a23582810fedb8c0bc47524558fb6c56aac3fc252cb306072fd2815da2a47c32", size = 3689163, upload_time = "2025-10-15T23:18:13.821Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/4c/59/6b26512964ace6480c3e54681a9859c974172fb141c38df11eadd8416947/cryptography-46.0.3-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:e7aec276d68421f9574040c26e2a7c3771060bc0cff408bae1dcb19d3ab1e63c", size = 3429474, upload_time = "2025-10-15T23:18:15.477Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/06/8a/e60e46adab4362a682cf142c7dcb5bf79b782ab2199b0dcb81f55970807f/cryptography-46.0.3-pp311-pypy311_pp73-macosx_10_9_x86_64.whl", hash = "sha256:7ce938a99998ed3c8aa7e7272dca1a610401ede816d36d0693907d863b10d9ea", size = 3698132, upload_time = "2025-10-15T23:18:17.056Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/da/38/f59940ec4ee91e93d3311f7532671a5cef5570eb04a144bf203b58552d11/cryptography-46.0.3-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:191bb60a7be5e6f54e30ba16fdfae78ad3a342a0599eb4193ba88e3f3d6e185b", size = 4243992, upload_time = "2025-10-15T23:18:18.695Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b0/0c/35b3d92ddebfdfda76bb485738306545817253d0a3ded0bfe80ef8e67aa5/cryptography-46.0.3-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:c70cc23f12726be8f8bc72e41d5065d77e4515efae3690326764ea1b07845cfb", size = 4409944, upload_time = "2025-10-15T23:18:20.597Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/99/55/181022996c4063fc0e7666a47049a1ca705abb9c8a13830f074edb347495/cryptography-46.0.3-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:9394673a9f4de09e28b5356e7fff97d778f8abad85c9d5ac4a4b7e25a0de7717", size = 4242957, upload_time = "2025-10-15T23:18:22.18Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ba/af/72cd6ef29f9c5f731251acadaeb821559fe25f10852f44a63374c9ca08c1/cryptography-46.0.3-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:94cd0549accc38d1494e1f8de71eca837d0509d0d44bf11d158524b0e12cebf9", size = 4409447, upload_time = "2025-10-15T23:18:24.209Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0d/c3/e90f4a4feae6410f914f8ebac129b9ae7a8c92eb60a638012dde42030a9d/cryptography-46.0.3-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:6b5063083824e5509fdba180721d55909ffacccc8adbec85268b48439423d78c", size = 3438528, upload_time = "2025-10-15T23:18:26.227Z" }, +] + +[[package]] +name = "cycler" +version = "0.12.1" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a9/95/a3dbbb5028f35eafb79008e7522a75244477d2838f38cbb722248dabc2a8/cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30" }, +] + +[[package]] +name = "distro" +version = "1.9.0" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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 = "exceptiongroup" +version = "1.3.1" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +dependencies = [ + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload_time = "2025-11-21T23:01:54.787Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8a/0e/97c33bf5009bdbac74fd2beace167cab3f978feb69cc36f1ef79360d6c4e/exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598", size = 16740, upload_time = "2025-11-21T23:01:53.443Z" }, +] + +[[package]] +name = "faiss-cpu" +version = "1.13.1" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +dependencies = [ + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }, marker = "python_full_version < '3.11'" }, + { name = "numpy", version = "2.3.5", source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "packaging" }, +] +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/66/92/c4f30580aee11fda3f424f8509d9b5ad96b9f44409f52a7ceb6b42880e50/faiss_cpu-1.13.1-cp310-abi3-macosx_14_0_arm64.whl", hash = "sha256:2967def7aa2da8efbf6a5da81138780aa17a9970ca666417cb632a00a593423d", size = 3418004, upload_time = "2025-12-05T01:01:51.955Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/04/1f/30803e63affa8bbdfd549f83ed5d39ccf900c030b6da8010d0b95f7ae1d1/faiss_cpu-1.13.1-cp310-abi3-macosx_14_0_x86_64.whl", hash = "sha256:30c179891656a988f5223e586c696432aacc5f4e763d85e165be30ef57ac2bbf", size = 7806468, upload_time = "2025-12-05T01:01:54.096Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/17/ae/40f66b640664af319ff8be87a9b0cc2c9ec025a2cf82b27cc27964fcf3c0/faiss_cpu-1.13.1-cp310-abi3-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff5bdbf392081659e6b0f98f03b602bf08d1b5a790e28aa1185ae925decff6b2", size = 11410471, upload_time = "2025-12-05T01:01:56.038Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/38/f8/b8f0862ec6af8a71c6410a61baa35571161f7dba616aed696e91cb464630/faiss_cpu-1.13.1-cp310-abi3-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3de25edb0e69c1b95eeda923b2e23da01f472b2cc3f4817e63b25a56847d6ea7", size = 23719213, upload_time = "2025-12-05T01:01:58.545Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/4c/ee/01e07e4e780b0b739a3299ca8e5b4751970629b0f2c51f5ec464718e9f9e/faiss_cpu-1.13.1-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0b2f0e6cd30511b9fe320a2309389269269d3e363cc88c3a0380095a8c08ae27", size = 13400767, upload_time = "2025-12-05T01:02:00.742Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/da/27/0c4e249fe50f87f1f038c80deebcdd28b23617bb42e3e5708b34c86fdae7/faiss_cpu-1.13.1-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:8ad542573ad05af6c508f4cf5268ba2aad06f0c8d4e780a0eeba7fe6fd274922", size = 24960102, upload_time = "2025-12-05T01:02:04.56Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ae/51/eddbd8468b27328d739128559155b3b36dc427e63355b5d3fb5c5c181198/faiss_cpu-1.13.1-cp310-cp310-win_amd64.whl", hash = "sha256:30e9c129e0beb9da699982d9068322e3808e0d0faab4652cabf2c08900ab7892", size = 18801122, upload_time = "2025-12-05T01:02:07.274Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/47/c1/93983f2be41d0ab24cefd8926d1246e744671b4dc0b577ad576eb1205bfa/faiss_cpu-1.13.1-cp311-cp311-win_amd64.whl", hash = "sha256:dbcf54daf14068b23c3d4116aa087eff6cf7cb43457c572318dfc2cbd944607a", size = 18802476, upload_time = "2025-12-05T01:02:10.09Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fa/a1/007e547cc7e8731346387a42001a06ee53394663616c84f3de247094158e/faiss_cpu-1.13.1-cp311-cp311-win_arm64.whl", hash = "sha256:9860949a70d1b25ff11ac9600aeda796db6710bf667b1f5508b44a63e6170b30", size = 8505159, upload_time = "2025-12-05T01:02:12.578Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/09/bc/ce942b00958ef52caca71666c06fa801fcd99dc61a9873ab067932dd3d5e/faiss_cpu-1.13.1-cp312-cp312-win_amd64.whl", hash = "sha256:0fece5b63e8d014f8db4abfe0b4c9a82e6508e64f450fce700e5cb4b47041f1a", size = 18812863, upload_time = "2025-12-05T01:02:14.982Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/47/ab/7b91c9cb328d960466e23cd9ca02f44d554ac5761d41262b74daa1715da1/faiss_cpu-1.13.1-cp312-cp312-win_arm64.whl", hash = "sha256:168986e3f152a7568257c5ac50f3cf1a1aaa34fb41e1ba7259799bcb8ffe687f", size = 8507940, upload_time = "2025-12-05T01:02:18.078Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/aa/75/0fb845be2e674531ce7f89207d7f932ffbc8fc50f866dba5569512305cc9/faiss_cpu-1.13.1-cp313-cp313-win_amd64.whl", hash = "sha256:5f71c8840794c39c1e1cdd92c2ef4d3f77b3e650f614f296e31c2545ad2bab51", size = 18812964, upload_time = "2025-12-05T01:02:20.505Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/00/2c/c13c816546ffc5b0b7f8ca64811b24b17d73ff6382464f1ab0eed87b7753/faiss_cpu-1.13.1-cp313-cp313-win_arm64.whl", hash = "sha256:24cb2d6ce2459c94e15a6cecfed15ff8d9f997aed7bae4037c0f045022030cb3", size = 8508631, upload_time = "2025-12-05T01:02:22.751Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/45/6f/adf064c644a80c0ebd499144ccbab672c9946361132617ceafcc48819771/faiss_cpu-1.13.1-cp314-cp314-win_amd64.whl", hash = "sha256:5195ab9149c563cafe4da8ab4cc0b84b177cbb1f8aa897a8c199e11ef4f37e16", size = 18816994, upload_time = "2025-12-05T01:02:25.055Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/61/53/042f863a6a1202af8eec94604dc8b192319253faabb8ee6070297a24c091/faiss_cpu-1.13.1-cp314-cp314-win_arm64.whl", hash = "sha256:ffc58173e24026ee4dc08c50dd3506ad553d4b2103892500b0d4ae9344027d57", size = 8511280, upload_time = "2025-12-05T01:02:27.163Z" }, +] + +[[package]] +name = "fastapi" +version = "0.124.0" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +dependencies = [ + { name = "annotated-doc" }, + { name = "pydantic" }, + { name = "starlette" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/48/9c/11969bd3e3bc4aa3a711f83dd3720239d3565a934929c74fc32f6c9f3638/fastapi-0.124.0.tar.gz", hash = "sha256:260cd178ad75e6d259991f2fd9b0fee924b224850079df576a3ba604ce58f4e6", size = 357623, upload_time = "2025-12-06T13:11:35.692Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/4d/29/9e1e82e16e9a1763d3b55bfbe9b2fa39d7175a1fd97685c482fa402e111d/fastapi-0.124.0-py3-none-any.whl", hash = "sha256:91596bdc6dde303c318f06e8d2bc75eafb341fc793a0c9c92c0bc1db1ac52480", size = 112505, upload_time = "2025-12-06T13:11:34.392Z" }, +] + +[[package]] +name = "fonttools" +version = "4.61.0" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/33/f9/0e84d593c0e12244150280a630999835a64f2852276161b62a0f98318de0/fonttools-4.61.0.tar.gz", hash = "sha256:ec520a1f0c7758d7a858a00f090c1745f6cde6a7c5e76fb70ea4044a15f712e7", size = 3561884, upload_time = "2025-11-28T17:05:49.491Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/29/f3/91bba2721fb173fc68e09d15b6ccf3ad4f83d127fbff579be7e5984888a6/fonttools-4.61.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:dc25a4a9c1225653e4431a9413d0381b1c62317b0f543bdcec24e1991f612f33", size = 2850151, upload_time = "2025-11-28T17:04:14.214Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f5/8c/a1691dec01038ac7e7bb3ab83300dcc5087b11d8f48640928c02a873eb92/fonttools-4.61.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6b493c32d2555e9944ec1b911ea649ff8f01a649ad9cba6c118d6798e932b3f0", size = 2389769, upload_time = "2025-11-28T17:04:16.443Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2d/dd/5bb369a44319d92ba25612511eb8ed2a6fa75239979e0388907525626902/fonttools-4.61.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ad751319dc532a79bdf628b8439af167181b4210a0cd28a8935ca615d9fdd727", size = 4893189, upload_time = "2025-11-28T17:04:18.398Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5e/02/51373fa8846bd22bb54e5efb30a824b417b058083f775a194a432f21a45f/fonttools-4.61.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2de14557d113faa5fb519f7f29c3abe4d69c17fe6a5a2595cc8cda7338029219", size = 4854415, upload_time = "2025-11-28T17:04:20.421Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8b/64/9cdbbb804577a7e6191448851c57e6a36eb02aa4bf6a9668b528c968e44e/fonttools-4.61.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:59587bbe455dbdf75354a9dbca1697a35a8903e01fab4248d6b98a17032cee52", size = 4870927, upload_time = "2025-11-28T17:04:22.625Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/92/68/e40b22919dc96dc30a70b58fec609ab85112de950bdecfadf8dd478c5a88/fonttools-4.61.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:46cb3d9279f758ac0cf671dc3482da877104b65682679f01b246515db03dbb72", size = 4988674, upload_time = "2025-11-28T17:04:24.675Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/9b/5c/e857349ce8aedb2451b9448282e86544b2b7f1c8b10ea0fe49b7cb369b72/fonttools-4.61.0-cp310-cp310-win32.whl", hash = "sha256:58b4f1b78dfbfe855bb8a6801b31b8cdcca0e2847ec769ad8e0b0b692832dd3b", size = 1497663, upload_time = "2025-11-28T17:04:26.598Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f9/0c/62961d5fe6f764d6cbc387ef2c001f5f610808c7aded837409836c0b3e7c/fonttools-4.61.0-cp310-cp310-win_amd64.whl", hash = "sha256:68704a8bbe0b61976262b255e90cde593dc0fe3676542d9b4d846bad2a890a76", size = 1546143, upload_time = "2025-11-28T17:04:28.432Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fd/be/5aa89cdddf2863d8afbdc19eb8ec5d8d35d40eeeb8e6cf52c5ff1c2dbd33/fonttools-4.61.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:a32a16951cbf113d38f1dd8551b277b6e06e0f6f776fece0f99f746d739e1be3", size = 2847553, upload_time = "2025-11-28T17:04:30.539Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0d/3e/6ff643b07cead1236a534f51291ae2981721cf419135af5b740c002a66dd/fonttools-4.61.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:328a9c227984bebaf69f3ac9062265f8f6acc7ddf2e4e344c63358579af0aa3d", size = 2388298, upload_time = "2025-11-28T17:04:32.161Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c3/15/fca8dfbe7b482e6f240b1aad0ed7c6e2e75e7a28efa3d3a03b570617b5e5/fonttools-4.61.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2f0bafc8a3b3749c69cc610e5aa3da832d39c2a37a68f03d18ec9a02ecaac04a", size = 5054133, upload_time = "2025-11-28T17:04:34.035Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6a/a2/821c61c691b21fd09e07528a9a499cc2b075ac83ddb644aa16c9875a64bc/fonttools-4.61.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b5ca59b7417d149cf24e4c1933c9f44b2957424fc03536f132346d5242e0ebe5", size = 5031410, upload_time = "2025-11-28T17:04:36.141Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e8/f6/8b16339e93d03c732c8a23edefe3061b17a5f9107ddc47a3215ecd054cac/fonttools-4.61.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:df8cbce85cf482eb01f4551edca978c719f099c623277bda8332e5dbe7dba09d", size = 5030005, upload_time = "2025-11-28T17:04:38.314Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ac/eb/d4e150427bdaa147755239c931bbce829a88149ade5bfd8a327afe565567/fonttools-4.61.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:7fb5b84f48a6a733ca3d7f41aa9551908ccabe8669ffe79586560abcc00a9cfd", size = 5154026, upload_time = "2025-11-28T17:04:40.34Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/7f/5f/3dd00ce0dba6759943c707b1830af8c0bcf6f8f1a9fe46cb82e7ac2aaa74/fonttools-4.61.0-cp311-cp311-win32.whl", hash = "sha256:787ef9dfd1ea9fe49573c272412ae5f479d78e671981819538143bec65863865", size = 2276035, upload_time = "2025-11-28T17:04:42.59Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/4e/44/798c472f096ddf12955eddb98f4f7c906e7497695d04ce073ddf7161d134/fonttools-4.61.0-cp311-cp311-win_amd64.whl", hash = "sha256:14fafda386377b6131d9e448af42d0926bad47e038de0e5ba1d58c25d621f028", size = 2327290, upload_time = "2025-11-28T17:04:44.57Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/00/5d/19e5939f773c7cb05480fe2e881d63870b63ee2b4bdb9a77d55b1d36c7b9/fonttools-4.61.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e24a1565c4e57111ec7f4915f8981ecbb61adf66a55f378fdc00e206059fcfef", size = 2846930, upload_time = "2025-11-28T17:04:46.639Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/25/b2/0658faf66f705293bd7e739a4f038302d188d424926be9c59bdad945664b/fonttools-4.61.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:e2bfacb5351303cae9f072ccf3fc6ecb437a6f359c0606bae4b1ab6715201d87", size = 2383016, upload_time = "2025-11-28T17:04:48.525Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/29/a3/1fa90b95b690f0d7541f48850adc40e9019374d896c1b8148d15012b2458/fonttools-4.61.0-cp312-cp312-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:0bdcf2e29d65c26299cc3d502f4612365e8b90a939f46cd92d037b6cb7bb544a", size = 4949425, upload_time = "2025-11-28T17:04:50.482Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/af/00/acf18c00f6c501bd6e05ee930f926186f8a8e268265407065688820f1c94/fonttools-4.61.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e6cd0d9051b8ddaf7385f99dd82ec2a058e2b46cf1f1961e68e1ff20fcbb61af", size = 4999632, upload_time = "2025-11-28T17:04:52.508Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5f/e0/19a2b86e54109b1d2ee8743c96a1d297238ae03243897bc5345c0365f34d/fonttools-4.61.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e074bc07c31406f45c418e17c1722e83560f181d122c412fa9e815df0ff74810", size = 4939438, upload_time = "2025-11-28T17:04:54.437Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/04/35/7b57a5f57d46286360355eff8d6b88c64ab6331107f37a273a71c803798d/fonttools-4.61.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5a9b78da5d5faa17e63b2404b77feeae105c1b7e75f26020ab7a27b76e02039f", size = 5088960, upload_time = "2025-11-28T17:04:56.348Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3e/0e/6c5023eb2e0fe5d1ababc7e221e44acd3ff668781489cc1937a6f83d620a/fonttools-4.61.0-cp312-cp312-win32.whl", hash = "sha256:9821ed77bb676736b88fa87a737c97b6af06e8109667e625a4f00158540ce044", size = 2264404, upload_time = "2025-11-28T17:04:58.149Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/36/0b/63273128c7c5df19b1e4cd92e0a1e6ea5bb74a400c4905054c96ad60a675/fonttools-4.61.0-cp312-cp312-win_amd64.whl", hash = "sha256:0011d640afa61053bc6590f9a3394bd222de7cfde19346588beabac374e9d8ac", size = 2314427, upload_time = "2025-11-28T17:04:59.812Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/17/45/334f0d7f181e5473cfb757e1b60f4e60e7fc64f28d406e5d364a952718c0/fonttools-4.61.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ba774b8cbd8754f54b8eb58124e8bd45f736b2743325ab1a5229698942b9b433", size = 2841801, upload_time = "2025-11-28T17:05:01.621Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/cc/63/97b9c78e1f79bc741d4efe6e51f13872d8edb2b36e1b9fb2bab0d4491bb7/fonttools-4.61.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c84b430616ed73ce46e9cafd0bf0800e366a3e02fb7e1ad7c1e214dbe3862b1f", size = 2379024, upload_time = "2025-11-28T17:05:03.668Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/4e/80/c87bc524a90dbeb2a390eea23eae448286983da59b7e02c67fa0ca96a8c5/fonttools-4.61.0-cp313-cp313-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b2b734d8391afe3c682320840c8191de9bd24e7eb85768dd4dc06ed1b63dbb1b", size = 4923706, upload_time = "2025-11-28T17:05:05.494Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6d/f6/a3b0374811a1de8c3f9207ec88f61ad1bb96f938ed89babae26c065c2e46/fonttools-4.61.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a5c5fff72bf31b0e558ed085e4fd7ed96eb85881404ecc39ed2a779e7cf724eb", size = 4979751, upload_time = "2025-11-28T17:05:07.665Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a5/3b/30f63b4308b449091573285f9d27619563a84f399946bca3eadc9554afbe/fonttools-4.61.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:14a290c5c93fcab76b7f451e6a4b7721b712d90b3b5ed6908f1abcf794e90d6d", size = 4921113, upload_time = "2025-11-28T17:05:09.551Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/41/6c/58e6e9b7d9d8bf2d7010bd7bb493060b39b02a12d1cda64a8bfb116ce760/fonttools-4.61.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:13e3e20a5463bfeb77b3557d04b30bd6a96a6bb5c15c7b2e7908903e69d437a0", size = 5063183, upload_time = "2025-11-28T17:05:11.677Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3f/e3/52c790ab2b07492df059947a1fd7778e105aac5848c0473029a4d20481a2/fonttools-4.61.0-cp313-cp313-win32.whl", hash = "sha256:6781e7a4bb010be1cd69a29927b0305c86b843395f2613bdabe115f7d6ea7f34", size = 2263159, upload_time = "2025-11-28T17:05:13.292Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e9/1f/116013b200fbeba871046554d5d2a45fefa69a05c40e9cdfd0d4fff53edc/fonttools-4.61.0-cp313-cp313-win_amd64.whl", hash = "sha256:c53b47834ae41e8e4829171cc44fec0fdf125545a15f6da41776b926b9645a9a", size = 2313530, upload_time = "2025-11-28T17:05:14.848Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d3/99/59b1e25987787cb714aa9457cee4c9301b7c2153f0b673e2b8679d37669d/fonttools-4.61.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:96dfc9bc1f2302224e48e6ee37e656eddbab810b724b52e9d9c13a57a6abad01", size = 2841429, upload_time = "2025-11-28T17:05:16.671Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2b/b2/4c1911d4332c8a144bb3b44416e274ccca0e297157c971ea1b3fbb855590/fonttools-4.61.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:3b2065d94e5d63aafc2591c8b6ccbdb511001d9619f1bca8ad39b745ebeb5efa", size = 2378987, upload_time = "2025-11-28T17:05:18.69Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/24/b0/f442e90fde5d2af2ae0cb54008ab6411edc557ee33b824e13e1d04925ac9/fonttools-4.61.0-cp314-cp314-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:e0d87e81e4d869549585ba0beb3f033718501c1095004f5e6aef598d13ebc216", size = 4873270, upload_time = "2025-11-28T17:05:20.625Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/bb/04/f5d5990e33053c8a59b90b1d7e10ad9b97a73f42c745304da0e709635fab/fonttools-4.61.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1cfa2eb9bae650e58f0e8ad53c49d19a844d6034d6b259f30f197238abc1ccee", size = 4968270, upload_time = "2025-11-28T17:05:22.515Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/94/9f/2091402e0d27c9c8c4bab5de0e5cd146d9609a2d7d1c666bbb75c0011c1a/fonttools-4.61.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:4238120002e68296d55e091411c09eab94e111c8ce64716d17df53fd0eb3bb3d", size = 4919799, upload_time = "2025-11-28T17:05:24.437Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a8/72/86adab22fde710b829f8ffbc8f264df01928e5b7a8f6177fa29979ebf256/fonttools-4.61.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:b6ceac262cc62bec01b3bb59abccf41b24ef6580869e306a4e88b7e56bb4bdda", size = 5030966, upload_time = "2025-11-28T17:05:26.115Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e8/a7/7c8e31b003349e845b853f5e0a67b95ff6b052fa4f5224f8b72624f5ac69/fonttools-4.61.0-cp314-cp314-win32.whl", hash = "sha256:adbb4ecee1a779469a77377bbe490565effe8fce6fb2e6f95f064de58f8bac85", size = 2267243, upload_time = "2025-11-28T17:05:27.807Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/20/ee/f434fe7749360497c52b7dcbcfdbccdaab0a71c59f19d572576066717122/fonttools-4.61.0-cp314-cp314-win_amd64.whl", hash = "sha256:02bdf8e04d1a70476564b8640380f04bb4ac74edc1fc71f1bacb840b3e398ee9", size = 2318822, upload_time = "2025-11-28T17:05:29.882Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/33/b3/c16255320255e5c1863ca2b2599bb61a46e2f566db0bbb9948615a8fe692/fonttools-4.61.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:627216062d90ab0d98215176d8b9562c4dd5b61271d35f130bcd30f6a8aaa33a", size = 2924917, upload_time = "2025-11-28T17:05:31.46Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e2/b8/08067ae21de705a817777c02ef36ab0b953cbe91d8adf134f9c2da75ed6d/fonttools-4.61.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:7b446623c9cd5f14a59493818eaa80255eec2468c27d2c01b56e05357c263195", size = 2413576, upload_time = "2025-11-28T17:05:33.343Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/42/f1/96ff43f92addce2356780fdc203f2966206f3d22ea20e242c27826fd7442/fonttools-4.61.0-cp314-cp314t-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:70e2a0c0182ee75e493ef33061bfebf140ea57e035481d2f95aa03b66c7a0e05", size = 4877447, upload_time = "2025-11-28T17:05:35.278Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d0/1e/a3d8e51ed9ccfd7385e239ae374b78d258a0fb82d82cab99160a014a45d1/fonttools-4.61.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9064b0f55b947e929ac669af5311ab1f26f750214db6dd9a0c97e091e918f486", size = 5095681, upload_time = "2025-11-28T17:05:37.142Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/eb/f6/d256bd6c1065c146a0bdddf1c62f542e08ae5b3405dbf3fcc52be272f674/fonttools-4.61.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:2cb5e45a824ce14b90510024d0d39dae51bd4fbb54c42a9334ea8c8cf4d95cbe", size = 4974140, upload_time = "2025-11-28T17:05:39.5Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5d/0c/96633eb4b26f138cc48561c6e0c44b4ea48acea56b20b507d6b14f8e80ce/fonttools-4.61.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6e5ca8c62efdec7972dfdfd454415c4db49b89aeaefaaacada432f3b7eea9866", size = 5001741, upload_time = "2025-11-28T17:05:41.424Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6f/9a/3b536bad3be4f26186f296e749ff17bad3e6d57232c104d752d24b2e265b/fonttools-4.61.0-cp314-cp314t-win32.whl", hash = "sha256:63c7125d31abe3e61d7bb917329b5543c5b3448db95f24081a13aaf064360fc8", size = 2330707, upload_time = "2025-11-28T17:05:43.548Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/18/ea/e6b9ac610451ee9f04477c311ad126de971f6112cb579fa391d2a8edb00b/fonttools-4.61.0-cp314-cp314t-win_amd64.whl", hash = "sha256:67d841aa272be5500de7f447c40d1d8452783af33b4c3599899319f6ef9ad3c1", size = 2395950, upload_time = "2025-11-28T17:05:45.638Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0c/14/634f7daea5ffe6a5f7a0322ba8e1a0e23c9257b80aa91458107896d1dfc7/fonttools-4.61.0-py3-none-any.whl", hash = "sha256:276f14c560e6f98d24ef7f5f44438e55ff5a67f78fa85236b218462c9f5d0635", size = 1144485, upload_time = "2025-11-28T17:05:47.573Z" }, +] + +[[package]] +name = "frozenlist" +version = "1.8.0" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2d/f5/c831fac6cc817d26fd54c7eaccd04ef7e0288806943f7cc5bbf69f3ac1f0/frozenlist-1.8.0.tar.gz", hash = "sha256:3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad", size = 45875, upload_time = "2025-10-06T05:38:17.865Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/83/4a/557715d5047da48d54e659203b9335be7bfaafda2c3f627b7c47e0b3aaf3/frozenlist-1.8.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:b37f6d31b3dcea7deb5e9696e529a6aa4a898adc33db82da12e4c60a7c4d2011", size = 86230, upload_time = "2025-10-06T05:35:23.699Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a2/fb/c85f9fed3ea8fe8740e5b46a59cc141c23b842eca617da8876cfce5f760e/frozenlist-1.8.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ef2b7b394f208233e471abc541cc6991f907ffd47dc72584acee3147899d6565", size = 49621, upload_time = "2025-10-06T05:35:25.341Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/63/70/26ca3f06aace16f2352796b08704338d74b6d1a24ca38f2771afbb7ed915/frozenlist-1.8.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a88f062f072d1589b7b46e951698950e7da00442fc1cacbe17e19e025dc327ad", size = 49889, upload_time = "2025-10-06T05:35:26.797Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5d/ed/c7895fd2fde7f3ee70d248175f9b6cdf792fb741ab92dc59cd9ef3bd241b/frozenlist-1.8.0-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:f57fb59d9f385710aa7060e89410aeb5058b99e62f4d16b08b91986b9a2140c2", size = 219464, upload_time = "2025-10-06T05:35:28.254Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6b/83/4d587dccbfca74cb8b810472392ad62bfa100bf8108c7223eb4c4fa2f7b3/frozenlist-1.8.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:799345ab092bee59f01a915620b5d014698547afd011e691a208637312db9186", size = 221649, upload_time = "2025-10-06T05:35:29.454Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6a/c6/fd3b9cd046ec5fff9dab66831083bc2077006a874a2d3d9247dea93ddf7e/frozenlist-1.8.0-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c23c3ff005322a6e16f71bf8692fcf4d5a304aaafe1e262c98c6d4adc7be863e", size = 219188, upload_time = "2025-10-06T05:35:30.951Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ce/80/6693f55eb2e085fc8afb28cf611448fb5b90e98e068fa1d1b8d8e66e5c7d/frozenlist-1.8.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8a76ea0f0b9dfa06f254ee06053d93a600865b3274358ca48a352ce4f0798450", size = 231748, upload_time = "2025-10-06T05:35:32.101Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/97/d6/e9459f7c5183854abd989ba384fe0cc1a0fb795a83c033f0571ec5933ca4/frozenlist-1.8.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c7366fe1418a6133d5aa824ee53d406550110984de7637d65a178010f759c6ef", size = 236351, upload_time = "2025-10-06T05:35:33.834Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/97/92/24e97474b65c0262e9ecd076e826bfd1d3074adcc165a256e42e7b8a7249/frozenlist-1.8.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:13d23a45c4cebade99340c4165bd90eeb4a56c6d8a9d8aa49568cac19a6d0dc4", size = 218767, upload_time = "2025-10-06T05:35:35.205Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ee/bf/dc394a097508f15abff383c5108cb8ad880d1f64a725ed3b90d5c2fbf0bb/frozenlist-1.8.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:e4a3408834f65da56c83528fb52ce7911484f0d1eaf7b761fc66001db1646eff", size = 235887, upload_time = "2025-10-06T05:35:36.354Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/40/90/25b201b9c015dbc999a5baf475a257010471a1fa8c200c843fd4abbee725/frozenlist-1.8.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:42145cd2748ca39f32801dad54aeea10039da6f86e303659db90db1c4b614c8c", size = 228785, upload_time = "2025-10-06T05:35:37.949Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/84/f4/b5bc148df03082f05d2dd30c089e269acdbe251ac9a9cf4e727b2dbb8a3d/frozenlist-1.8.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:e2de870d16a7a53901e41b64ffdf26f2fbb8917b3e6ebf398098d72c5b20bd7f", size = 230312, upload_time = "2025-10-06T05:35:39.178Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/db/4b/87e95b5d15097c302430e647136b7d7ab2398a702390cf4c8601975709e7/frozenlist-1.8.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:20e63c9493d33ee48536600d1a5c95eefc870cd71e7ab037763d1fbb89cc51e7", size = 217650, upload_time = "2025-10-06T05:35:40.377Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e5/70/78a0315d1fea97120591a83e0acd644da638c872f142fd72a6cebee825f3/frozenlist-1.8.0-cp310-cp310-win32.whl", hash = "sha256:adbeebaebae3526afc3c96fad434367cafbfd1b25d72369a9e5858453b1bb71a", size = 39659, upload_time = "2025-10-06T05:35:41.863Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/66/aa/3f04523fb189a00e147e60c5b2205126118f216b0aa908035c45336e27e4/frozenlist-1.8.0-cp310-cp310-win_amd64.whl", hash = "sha256:667c3777ca571e5dbeb76f331562ff98b957431df140b54c85fd4d52eea8d8f6", size = 43837, upload_time = "2025-10-06T05:35:43.205Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/39/75/1135feecdd7c336938bd55b4dc3b0dfc46d85b9be12ef2628574b28de776/frozenlist-1.8.0-cp310-cp310-win_arm64.whl", hash = "sha256:80f85f0a7cc86e7a54c46d99c9e1318ff01f4687c172ede30fd52d19d1da1c8e", size = 39989, upload_time = "2025-10-06T05:35:44.596Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/bc/03/077f869d540370db12165c0aa51640a873fb661d8b315d1d4d67b284d7ac/frozenlist-1.8.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:09474e9831bc2b2199fad6da3c14c7b0fbdd377cce9d3d77131be28906cb7d84", size = 86912, upload_time = "2025-10-06T05:35:45.98Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/df/b5/7610b6bd13e4ae77b96ba85abea1c8cb249683217ef09ac9e0ae93f25a91/frozenlist-1.8.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:17c883ab0ab67200b5f964d2b9ed6b00971917d5d8a92df149dc2c9779208ee9", size = 50046, upload_time = "2025-10-06T05:35:47.009Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6e/ef/0e8f1fe32f8a53dd26bdd1f9347efe0778b0fddf62789ea683f4cc7d787d/frozenlist-1.8.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fa47e444b8ba08fffd1c18e8cdb9a75db1b6a27f17507522834ad13ed5922b93", size = 50119, upload_time = "2025-10-06T05:35:48.38Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/11/b1/71a477adc7c36e5fb628245dfbdea2166feae310757dea848d02bd0689fd/frozenlist-1.8.0-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2552f44204b744fba866e573be4c1f9048d6a324dfe14475103fd51613eb1d1f", size = 231067, upload_time = "2025-10-06T05:35:49.97Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/45/7e/afe40eca3a2dc19b9904c0f5d7edfe82b5304cb831391edec0ac04af94c2/frozenlist-1.8.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:957e7c38f250991e48a9a73e6423db1bb9dd14e722a10f6b8bb8e16a0f55f695", size = 233160, upload_time = "2025-10-06T05:35:51.729Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a6/aa/7416eac95603ce428679d273255ffc7c998d4132cfae200103f164b108aa/frozenlist-1.8.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:8585e3bb2cdea02fc88ffa245069c36555557ad3609e83be0ec71f54fd4abb52", size = 228544, upload_time = "2025-10-06T05:35:53.246Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8b/3d/2a2d1f683d55ac7e3875e4263d28410063e738384d3adc294f5ff3d7105e/frozenlist-1.8.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:edee74874ce20a373d62dc28b0b18b93f645633c2943fd90ee9d898550770581", size = 243797, upload_time = "2025-10-06T05:35:54.497Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/78/1e/2d5565b589e580c296d3bb54da08d206e797d941a83a6fdea42af23be79c/frozenlist-1.8.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c9a63152fe95756b85f31186bddf42e4c02c6321207fd6601a1c89ebac4fe567", size = 247923, upload_time = "2025-10-06T05:35:55.861Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/aa/c3/65872fcf1d326a7f101ad4d86285c403c87be7d832b7470b77f6d2ed5ddc/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b6db2185db9be0a04fecf2f241c70b63b1a242e2805be291855078f2b404dd6b", size = 230886, upload_time = "2025-10-06T05:35:57.399Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a0/76/ac9ced601d62f6956f03cc794f9e04c81719509f85255abf96e2510f4265/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:f4be2e3d8bc8aabd566f8d5b8ba7ecc09249d74ba3c9ed52e54dc23a293f0b92", size = 245731, upload_time = "2025-10-06T05:35:58.563Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b9/49/ecccb5f2598daf0b4a1415497eba4c33c1e8ce07495eb07d2860c731b8d5/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:c8d1634419f39ea6f5c427ea2f90ca85126b54b50837f31497f3bf38266e853d", size = 241544, upload_time = "2025-10-06T05:35:59.719Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/53/4b/ddf24113323c0bbcc54cb38c8b8916f1da7165e07b8e24a717b4a12cbf10/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:1a7fa382a4a223773ed64242dbe1c9c326ec09457e6b8428efb4118c685c3dfd", size = 241806, upload_time = "2025-10-06T05:36:00.959Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a7/fb/9b9a084d73c67175484ba2789a59f8eebebd0827d186a8102005ce41e1ba/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:11847b53d722050808926e785df837353bd4d75f1d494377e59b23594d834967", size = 229382, upload_time = "2025-10-06T05:36:02.22Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/95/a3/c8fb25aac55bf5e12dae5c5aa6a98f85d436c1dc658f21c3ac73f9fa95e5/frozenlist-1.8.0-cp311-cp311-win32.whl", hash = "sha256:27c6e8077956cf73eadd514be8fb04d77fc946a7fe9f7fe167648b0b9085cc25", size = 39647, upload_time = "2025-10-06T05:36:03.409Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0a/f5/603d0d6a02cfd4c8f2a095a54672b3cf967ad688a60fb9faf04fc4887f65/frozenlist-1.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:ac913f8403b36a2c8610bbfd25b8013488533e71e62b4b4adce9c86c8cea905b", size = 44064, upload_time = "2025-10-06T05:36:04.368Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5d/16/c2c9ab44e181f043a86f9a8f84d5124b62dbcb3a02c0977ec72b9ac1d3e0/frozenlist-1.8.0-cp311-cp311-win_arm64.whl", hash = "sha256:d4d3214a0f8394edfa3e303136d0575eece0745ff2b47bd2cb2e66dd92d4351a", size = 39937, upload_time = "2025-10-06T05:36:05.669Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/69/29/948b9aa87e75820a38650af445d2ef2b6b8a6fab1a23b6bb9e4ef0be2d59/frozenlist-1.8.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:78f7b9e5d6f2fdb88cdde9440dc147259b62b9d3b019924def9f6478be254ac1", size = 87782, upload_time = "2025-10-06T05:36:06.649Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/64/80/4f6e318ee2a7c0750ed724fa33a4bdf1eacdc5a39a7a24e818a773cd91af/frozenlist-1.8.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:229bf37d2e4acdaf808fd3f06e854a4a7a3661e871b10dc1f8f1896a3b05f18b", size = 50594, upload_time = "2025-10-06T05:36:07.69Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2b/94/5c8a2b50a496b11dd519f4a24cb5496cf125681dd99e94c604ccdea9419a/frozenlist-1.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f833670942247a14eafbb675458b4e61c82e002a148f49e68257b79296e865c4", size = 50448, upload_time = "2025-10-06T05:36:08.78Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6a/bd/d91c5e39f490a49df14320f4e8c80161cfcce09f1e2cde1edd16a551abb3/frozenlist-1.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:494a5952b1c597ba44e0e78113a7266e656b9794eec897b19ead706bd7074383", size = 242411, upload_time = "2025-10-06T05:36:09.801Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8f/83/f61505a05109ef3293dfb1ff594d13d64a2324ac3482be2cedc2be818256/frozenlist-1.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96f423a119f4777a4a056b66ce11527366a8bb92f54e541ade21f2374433f6d4", size = 243014, upload_time = "2025-10-06T05:36:11.394Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d8/cb/cb6c7b0f7d4023ddda30cf56b8b17494eb3a79e3fda666bf735f63118b35/frozenlist-1.8.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3462dd9475af2025c31cc61be6652dfa25cbfb56cbbf52f4ccfe029f38decaf8", size = 234909, upload_time = "2025-10-06T05:36:12.598Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/31/c5/cd7a1f3b8b34af009fb17d4123c5a778b44ae2804e3ad6b86204255f9ec5/frozenlist-1.8.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c4c800524c9cd9bac5166cd6f55285957fcfc907db323e193f2afcd4d9abd69b", size = 250049, upload_time = "2025-10-06T05:36:14.065Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c0/01/2f95d3b416c584a1e7f0e1d6d31998c4a795f7544069ee2e0962a4b60740/frozenlist-1.8.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d6a5df73acd3399d893dafc71663ad22534b5aa4f94e8a2fabfe856c3c1b6a52", size = 256485, upload_time = "2025-10-06T05:36:15.39Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ce/03/024bf7720b3abaebcff6d0793d73c154237b85bdf67b7ed55e5e9596dc9a/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:405e8fe955c2280ce66428b3ca55e12b3c4e9c336fb2103a4937e891c69a4a29", size = 237619, upload_time = "2025-10-06T05:36:16.558Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/69/fa/f8abdfe7d76b731f5d8bd217827cf6764d4f1d9763407e42717b4bed50a0/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:908bd3f6439f2fef9e85031b59fd4f1297af54415fb60e4254a95f75b3cab3f3", size = 250320, upload_time = "2025-10-06T05:36:17.821Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f5/3c/b051329f718b463b22613e269ad72138cc256c540f78a6de89452803a47d/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:294e487f9ec720bd8ffcebc99d575f7eff3568a08a253d1ee1a0378754b74143", size = 246820, upload_time = "2025-10-06T05:36:19.046Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0f/ae/58282e8f98e444b3f4dd42448ff36fa38bef29e40d40f330b22e7108f565/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:74c51543498289c0c43656701be6b077f4b265868fa7f8a8859c197006efb608", size = 250518, upload_time = "2025-10-06T05:36:20.763Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8f/96/007e5944694d66123183845a106547a15944fbbb7154788cbf7272789536/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:776f352e8329135506a1d6bf16ac3f87bc25b28e765949282dcc627af36123aa", size = 239096, upload_time = "2025-10-06T05:36:22.129Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/66/bb/852b9d6db2fa40be96f29c0d1205c306288f0684df8fd26ca1951d461a56/frozenlist-1.8.0-cp312-cp312-win32.whl", hash = "sha256:433403ae80709741ce34038da08511d4a77062aa924baf411ef73d1146e74faf", size = 39985, upload_time = "2025-10-06T05:36:23.661Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b8/af/38e51a553dd66eb064cdf193841f16f077585d4d28394c2fa6235cb41765/frozenlist-1.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:34187385b08f866104f0c0617404c8eb08165ab1272e884abc89c112e9c00746", size = 44591, upload_time = "2025-10-06T05:36:24.958Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a7/06/1dc65480ab147339fecc70797e9c2f69d9cea9cf38934ce08df070fdb9cb/frozenlist-1.8.0-cp312-cp312-win_arm64.whl", hash = "sha256:fe3c58d2f5db5fbd18c2987cba06d51b0529f52bc3a6cdc33d3f4eab725104bd", size = 40102, upload_time = "2025-10-06T05:36:26.333Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2d/40/0832c31a37d60f60ed79e9dfb5a92e1e2af4f40a16a29abcc7992af9edff/frozenlist-1.8.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8d92f1a84bb12d9e56f818b3a746f3efba93c1b63c8387a73dde655e1e42282a", size = 85717, upload_time = "2025-10-06T05:36:27.341Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/30/ba/b0b3de23f40bc55a7057bd38434e25c34fa48e17f20ee273bbde5e0650f3/frozenlist-1.8.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:96153e77a591c8adc2ee805756c61f59fef4cf4073a9275ee86fe8cba41241f7", size = 49651, upload_time = "2025-10-06T05:36:28.855Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0c/ab/6e5080ee374f875296c4243c381bbdef97a9ac39c6e3ce1d5f7d42cb78d6/frozenlist-1.8.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f21f00a91358803399890ab167098c131ec2ddd5f8f5fd5fe9c9f2c6fcd91e40", size = 49417, upload_time = "2025-10-06T05:36:29.877Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d5/4e/e4691508f9477ce67da2015d8c00acd751e6287739123113a9fca6f1604e/frozenlist-1.8.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:fb30f9626572a76dfe4293c7194a09fb1fe93ba94c7d4f720dfae3b646b45027", size = 234391, upload_time = "2025-10-06T05:36:31.301Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/40/76/c202df58e3acdf12969a7895fd6f3bc016c642e6726aa63bd3025e0fc71c/frozenlist-1.8.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eaa352d7047a31d87dafcacbabe89df0aa506abb5b1b85a2fb91bc3faa02d822", size = 233048, upload_time = "2025-10-06T05:36:32.531Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f9/c0/8746afb90f17b73ca5979c7a3958116e105ff796e718575175319b5bb4ce/frozenlist-1.8.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:03ae967b4e297f58f8c774c7eabcce57fe3c2434817d4385c50661845a058121", size = 226549, upload_time = "2025-10-06T05:36:33.706Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/7e/eb/4c7eefc718ff72f9b6c4893291abaae5fbc0c82226a32dcd8ef4f7a5dbef/frozenlist-1.8.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f6292f1de555ffcc675941d65fffffb0a5bcd992905015f85d0592201793e0e5", size = 239833, upload_time = "2025-10-06T05:36:34.947Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c2/4e/e5c02187cf704224f8b21bee886f3d713ca379535f16893233b9d672ea71/frozenlist-1.8.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:29548f9b5b5e3460ce7378144c3010363d8035cea44bc0bf02d57f5a685e084e", size = 245363, upload_time = "2025-10-06T05:36:36.534Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/1f/96/cb85ec608464472e82ad37a17f844889c36100eed57bea094518bf270692/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ec3cc8c5d4084591b4237c0a272cc4f50a5b03396a47d9caaf76f5d7b38a4f11", size = 229314, upload_time = "2025-10-06T05:36:38.582Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5d/6f/4ae69c550e4cee66b57887daeebe006fe985917c01d0fff9caab9883f6d0/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:517279f58009d0b1f2e7c1b130b377a349405da3f7621ed6bfae50b10adf20c1", size = 243365, upload_time = "2025-10-06T05:36:40.152Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/7a/58/afd56de246cf11780a40a2c28dc7cbabbf06337cc8ddb1c780a2d97e88d8/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:db1e72ede2d0d7ccb213f218df6a078a9c09a7de257c2fe8fcef16d5925230b1", size = 237763, upload_time = "2025-10-06T05:36:41.355Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/cb/36/cdfaf6ed42e2644740d4a10452d8e97fa1c062e2a8006e4b09f1b5fd7d63/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:b4dec9482a65c54a5044486847b8a66bf10c9cb4926d42927ec4e8fd5db7fed8", size = 240110, upload_time = "2025-10-06T05:36:42.716Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/03/a8/9ea226fbefad669f11b52e864c55f0bd57d3c8d7eb07e9f2e9a0b39502e1/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:21900c48ae04d13d416f0e1e0c4d81f7931f73a9dfa0b7a8746fb2fe7dd970ed", size = 233717, upload_time = "2025-10-06T05:36:44.251Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/1e/0b/1b5531611e83ba7d13ccc9988967ea1b51186af64c42b7a7af465dcc9568/frozenlist-1.8.0-cp313-cp313-win32.whl", hash = "sha256:8b7b94a067d1c504ee0b16def57ad5738701e4ba10cec90529f13fa03c833496", size = 39628, upload_time = "2025-10-06T05:36:45.423Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d8/cf/174c91dbc9cc49bc7b7aab74d8b734e974d1faa8f191c74af9b7e80848e6/frozenlist-1.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:878be833caa6a3821caf85eb39c5ba92d28e85df26d57afb06b35b2efd937231", size = 43882, upload_time = "2025-10-06T05:36:46.796Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c1/17/502cd212cbfa96eb1388614fe39a3fc9ab87dbbe042b66f97acb57474834/frozenlist-1.8.0-cp313-cp313-win_arm64.whl", hash = "sha256:44389d135b3ff43ba8cc89ff7f51f5a0bb6b63d829c8300f79a2fe4fe61bcc62", size = 39676, upload_time = "2025-10-06T05:36:47.8Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d2/5c/3bbfaa920dfab09e76946a5d2833a7cbdf7b9b4a91c714666ac4855b88b4/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:e25ac20a2ef37e91c1b39938b591457666a0fa835c7783c3a8f33ea42870db94", size = 89235, upload_time = "2025-10-06T05:36:48.78Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d2/d6/f03961ef72166cec1687e84e8925838442b615bd0b8854b54923ce5b7b8a/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:07cdca25a91a4386d2e76ad992916a85038a9b97561bf7a3fd12d5d9ce31870c", size = 50742, upload_time = "2025-10-06T05:36:49.837Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/1e/bb/a6d12b7ba4c3337667d0e421f7181c82dda448ce4e7ad7ecd249a16fa806/frozenlist-1.8.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4e0c11f2cc6717e0a741f84a527c52616140741cd812a50422f83dc31749fb52", size = 51725, upload_time = "2025-10-06T05:36:50.851Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/bc/71/d1fed0ffe2c2ccd70b43714c6cab0f4188f09f8a67a7914a6b46ee30f274/frozenlist-1.8.0-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b3210649ee28062ea6099cfda39e147fa1bc039583c8ee4481cb7811e2448c51", size = 284533, upload_time = "2025-10-06T05:36:51.898Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c9/1f/fb1685a7b009d89f9bf78a42d94461bc06581f6e718c39344754a5d9bada/frozenlist-1.8.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:581ef5194c48035a7de2aefc72ac6539823bb71508189e5de01d60c9dcd5fa65", size = 292506, upload_time = "2025-10-06T05:36:53.101Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e6/3b/b991fe1612703f7e0d05c0cf734c1b77aaf7c7d321df4572e8d36e7048c8/frozenlist-1.8.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3ef2d026f16a2b1866e1d86fc4e1291e1ed8a387b2c333809419a2f8b3a77b82", size = 274161, upload_time = "2025-10-06T05:36:54.309Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ca/ec/c5c618767bcdf66e88945ec0157d7f6c4a1322f1473392319b7a2501ded7/frozenlist-1.8.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5500ef82073f599ac84d888e3a8c1f77ac831183244bfd7f11eaa0289fb30714", size = 294676, upload_time = "2025-10-06T05:36:55.566Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/7c/ce/3934758637d8f8a88d11f0585d6495ef54b2044ed6ec84492a91fa3b27aa/frozenlist-1.8.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:50066c3997d0091c411a66e710f4e11752251e6d2d73d70d8d5d4c76442a199d", size = 300638, upload_time = "2025-10-06T05:36:56.758Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fc/4f/a7e4d0d467298f42de4b41cbc7ddaf19d3cfeabaf9ff97c20c6c7ee409f9/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5c1c8e78426e59b3f8005e9b19f6ff46e5845895adbde20ece9218319eca6506", size = 283067, upload_time = "2025-10-06T05:36:57.965Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/dc/48/c7b163063d55a83772b268e6d1affb960771b0e203b632cfe09522d67ea5/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:eefdba20de0d938cec6a89bd4d70f346a03108a19b9df4248d3cf0d88f1b0f51", size = 292101, upload_time = "2025-10-06T05:36:59.237Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/9f/d0/2366d3c4ecdc2fd391e0afa6e11500bfba0ea772764d631bbf82f0136c9d/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:cf253e0e1c3ceb4aaff6df637ce033ff6535fb8c70a764a8f46aafd3d6ab798e", size = 289901, upload_time = "2025-10-06T05:37:00.811Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b8/94/daff920e82c1b70e3618a2ac39fbc01ae3e2ff6124e80739ce5d71c9b920/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:032efa2674356903cd0261c4317a561a6850f3ac864a63fc1583147fb05a79b0", size = 289395, upload_time = "2025-10-06T05:37:02.115Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e3/20/bba307ab4235a09fdcd3cc5508dbabd17c4634a1af4b96e0f69bfe551ebd/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6da155091429aeba16851ecb10a9104a108bcd32f6c1642867eadaee401c1c41", size = 283659, upload_time = "2025-10-06T05:37:03.711Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fd/00/04ca1c3a7a124b6de4f8a9a17cc2fcad138b4608e7a3fc5877804b8715d7/frozenlist-1.8.0-cp313-cp313t-win32.whl", hash = "sha256:0f96534f8bfebc1a394209427d0f8a63d343c9779cda6fc25e8e121b5fd8555b", size = 43492, upload_time = "2025-10-06T05:37:04.915Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/59/5e/c69f733a86a94ab10f68e496dc6b7e8bc078ebb415281d5698313e3af3a1/frozenlist-1.8.0-cp313-cp313t-win_amd64.whl", hash = "sha256:5d63a068f978fc69421fb0e6eb91a9603187527c86b7cd3f534a5b77a592b888", size = 48034, upload_time = "2025-10-06T05:37:06.343Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/16/6c/be9d79775d8abe79b05fa6d23da99ad6e7763a1d080fbae7290b286093fd/frozenlist-1.8.0-cp313-cp313t-win_arm64.whl", hash = "sha256:bf0a7e10b077bf5fb9380ad3ae8ce20ef919a6ad93b4552896419ac7e1d8e042", size = 41749, upload_time = "2025-10-06T05:37:07.431Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f1/c8/85da824b7e7b9b6e7f7705b2ecaf9591ba6f79c1177f324c2735e41d36a2/frozenlist-1.8.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:cee686f1f4cadeb2136007ddedd0aaf928ab95216e7691c63e50a8ec066336d0", size = 86127, upload_time = "2025-10-06T05:37:08.438Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8e/e8/a1185e236ec66c20afd72399522f142c3724c785789255202d27ae992818/frozenlist-1.8.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:119fb2a1bd47307e899c2fac7f28e85b9a543864df47aa7ec9d3c1b4545f096f", size = 49698, upload_time = "2025-10-06T05:37:09.48Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a1/93/72b1736d68f03fda5fdf0f2180fb6caaae3894f1b854d006ac61ecc727ee/frozenlist-1.8.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:4970ece02dbc8c3a92fcc5228e36a3e933a01a999f7094ff7c23fbd2beeaa67c", size = 49749, upload_time = "2025-10-06T05:37:10.569Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a7/b2/fabede9fafd976b991e9f1b9c8c873ed86f202889b864756f240ce6dd855/frozenlist-1.8.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:cba69cb73723c3f329622e34bdbf5ce1f80c21c290ff04256cff1cd3c2036ed2", size = 231298, upload_time = "2025-10-06T05:37:11.993Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3a/3b/d9b1e0b0eed36e70477ffb8360c49c85c8ca8ef9700a4e6711f39a6e8b45/frozenlist-1.8.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:778a11b15673f6f1df23d9586f83c4846c471a8af693a22e066508b77d201ec8", size = 232015, upload_time = "2025-10-06T05:37:13.194Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/dc/94/be719d2766c1138148564a3960fc2c06eb688da592bdc25adcf856101be7/frozenlist-1.8.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0325024fe97f94c41c08872db482cf8ac4800d80e79222c6b0b7b162d5b13686", size = 225038, upload_time = "2025-10-06T05:37:14.577Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e4/09/6712b6c5465f083f52f50cf74167b92d4ea2f50e46a9eea0523d658454ae/frozenlist-1.8.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:97260ff46b207a82a7567b581ab4190bd4dfa09f4db8a8b49d1a958f6aa4940e", size = 240130, upload_time = "2025-10-06T05:37:15.781Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f8/d4/cd065cdcf21550b54f3ce6a22e143ac9e4836ca42a0de1022da8498eac89/frozenlist-1.8.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:54b2077180eb7f83dd52c40b2750d0a9f175e06a42e3213ce047219de902717a", size = 242845, upload_time = "2025-10-06T05:37:17.037Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/62/c3/f57a5c8c70cd1ead3d5d5f776f89d33110b1addae0ab010ad774d9a44fb9/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:2f05983daecab868a31e1da44462873306d3cbfd76d1f0b5b69c473d21dbb128", size = 229131, upload_time = "2025-10-06T05:37:18.221Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6c/52/232476fe9cb64f0742f3fde2b7d26c1dac18b6d62071c74d4ded55e0ef94/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:33f48f51a446114bc5d251fb2954ab0164d5be02ad3382abcbfe07e2531d650f", size = 240542, upload_time = "2025-10-06T05:37:19.771Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5f/85/07bf3f5d0fb5414aee5f47d33c6f5c77bfe49aac680bfece33d4fdf6a246/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:154e55ec0655291b5dd1b8731c637ecdb50975a2ae70c606d100750a540082f7", size = 237308, upload_time = "2025-10-06T05:37:20.969Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/11/99/ae3a33d5befd41ac0ca2cc7fd3aa707c9c324de2e89db0e0f45db9a64c26/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:4314debad13beb564b708b4a496020e5306c7333fa9a3ab90374169a20ffab30", size = 238210, upload_time = "2025-10-06T05:37:22.252Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b2/60/b1d2da22f4970e7a155f0adde9b1435712ece01b3cd45ba63702aea33938/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:073f8bf8becba60aa931eb3bc420b217bb7d5b8f4750e6f8b3be7f3da85d38b7", size = 231972, upload_time = "2025-10-06T05:37:23.5Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3f/ab/945b2f32de889993b9c9133216c068b7fcf257d8595a0ac420ac8677cab0/frozenlist-1.8.0-cp314-cp314-win32.whl", hash = "sha256:bac9c42ba2ac65ddc115d930c78d24ab8d4f465fd3fc473cdedfccadb9429806", size = 40536, upload_time = "2025-10-06T05:37:25.581Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/59/ad/9caa9b9c836d9ad6f067157a531ac48b7d36499f5036d4141ce78c230b1b/frozenlist-1.8.0-cp314-cp314-win_amd64.whl", hash = "sha256:3e0761f4d1a44f1d1a47996511752cf3dcec5bbdd9cc2b4fe595caf97754b7a0", size = 44330, upload_time = "2025-10-06T05:37:26.928Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/82/13/e6950121764f2676f43534c555249f57030150260aee9dcf7d64efda11dd/frozenlist-1.8.0-cp314-cp314-win_arm64.whl", hash = "sha256:d1eaff1d00c7751b7c6662e9c5ba6eb2c17a2306ba5e2a37f24ddf3cc953402b", size = 40627, upload_time = "2025-10-06T05:37:28.075Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c0/c7/43200656ecc4e02d3f8bc248df68256cd9572b3f0017f0a0c4e93440ae23/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:d3bb933317c52d7ea5004a1c442eef86f426886fba134ef8cf4226ea6ee1821d", size = 89238, upload_time = "2025-10-06T05:37:29.373Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d1/29/55c5f0689b9c0fb765055629f472c0de484dcaf0acee2f7707266ae3583c/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8009897cdef112072f93a0efdce29cd819e717fd2f649ee3016efd3cd885a7ed", size = 50738, upload_time = "2025-10-06T05:37:30.792Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ba/7d/b7282a445956506fa11da8c2db7d276adcbf2b17d8bb8407a47685263f90/frozenlist-1.8.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2c5dcbbc55383e5883246d11fd179782a9d07a986c40f49abe89ddf865913930", size = 51739, upload_time = "2025-10-06T05:37:32.127Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/62/1c/3d8622e60d0b767a5510d1d3cf21065b9db874696a51ea6d7a43180a259c/frozenlist-1.8.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:39ecbc32f1390387d2aa4f5a995e465e9e2f79ba3adcac92d68e3e0afae6657c", size = 284186, upload_time = "2025-10-06T05:37:33.21Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2d/14/aa36d5f85a89679a85a1d44cd7a6657e0b1c75f61e7cad987b203d2daca8/frozenlist-1.8.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92db2bf818d5cc8d9c1f1fc56b897662e24ea5adb36ad1f1d82875bd64e03c24", size = 292196, upload_time = "2025-10-06T05:37:36.107Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/05/23/6bde59eb55abd407d34f77d39a5126fb7b4f109a3f611d3929f14b700c66/frozenlist-1.8.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2dc43a022e555de94c3b68a4ef0b11c4f747d12c024a520c7101709a2144fb37", size = 273830, upload_time = "2025-10-06T05:37:37.663Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d2/3f/22cff331bfad7a8afa616289000ba793347fcd7bc275f3b28ecea2a27909/frozenlist-1.8.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cb89a7f2de3602cfed448095bab3f178399646ab7c61454315089787df07733a", size = 294289, upload_time = "2025-10-06T05:37:39.261Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a4/89/5b057c799de4838b6c69aa82b79705f2027615e01be996d2486a69ca99c4/frozenlist-1.8.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:33139dc858c580ea50e7e60a1b0ea003efa1fd42e6ec7fdbad78fff65fad2fd2", size = 300318, upload_time = "2025-10-06T05:37:43.213Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/30/de/2c22ab3eb2a8af6d69dc799e48455813bab3690c760de58e1bf43b36da3e/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:168c0969a329b416119507ba30b9ea13688fafffac1b7822802537569a1cb0ef", size = 282814, upload_time = "2025-10-06T05:37:45.337Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/59/f7/970141a6a8dbd7f556d94977858cfb36fa9b66e0892c6dd780d2219d8cd8/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:28bd570e8e189d7f7b001966435f9dac6718324b5be2990ac496cf1ea9ddb7fe", size = 291762, upload_time = "2025-10-06T05:37:46.657Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c1/15/ca1adae83a719f82df9116d66f5bb28bb95557b3951903d39135620ef157/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b2a095d45c5d46e5e79ba1e5b9cb787f541a8dee0433836cea4b96a2c439dcd8", size = 289470, upload_time = "2025-10-06T05:37:47.946Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ac/83/dca6dc53bf657d371fbc88ddeb21b79891e747189c5de990b9dfff2ccba1/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:eab8145831a0d56ec9c4139b6c3e594c7a83c2c8be25d5bcf2d86136a532287a", size = 289042, upload_time = "2025-10-06T05:37:49.499Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/96/52/abddd34ca99be142f354398700536c5bd315880ed0a213812bc491cff5e4/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:974b28cf63cc99dfb2188d8d222bc6843656188164848c4f679e63dae4b0708e", size = 283148, upload_time = "2025-10-06T05:37:50.745Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/af/d3/76bd4ed4317e7119c2b7f57c3f6934aba26d277acc6309f873341640e21f/frozenlist-1.8.0-cp314-cp314t-win32.whl", hash = "sha256:342c97bf697ac5480c0a7ec73cd700ecfa5a8a40ac923bd035484616efecc2df", size = 44676, upload_time = "2025-10-06T05:37:52.222Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/89/76/c615883b7b521ead2944bb3480398cbb07e12b7b4e4d073d3752eb721558/frozenlist-1.8.0-cp314-cp314t-win_amd64.whl", hash = "sha256:06be8f67f39c8b1dc671f5d83aaefd3358ae5cdcf8314552c57e7ed3e6475bdd", size = 49451, upload_time = "2025-10-06T05:37:53.425Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e0/a3/5982da14e113d07b325230f95060e2169f5311b1017ea8af2a29b374c289/frozenlist-1.8.0-cp314-cp314t-win_arm64.whl", hash = "sha256:102e6314ca4da683dca92e3b1355490fed5f313b768500084fbe6371fddfdb79", size = 42507, upload_time = "2025-10-06T05:37:54.513Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", hash = "sha256:0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d", size = 13409, upload_time = "2025-10-06T05:38:16.721Z" }, +] + +[[package]] +name = "google-auth" +version = "2.43.0" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +dependencies = [ + { name = "cachetools" }, + { name = "pyasn1-modules" }, + { name = "rsa" }, +] +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ff/ef/66d14cf0e01b08d2d51ffc3c20410c4e134a1548fc246a6081eae585a4fe/google_auth-2.43.0.tar.gz", hash = "sha256:88228eee5fc21b62a1b5fe773ca15e67778cb07dc8363adcb4a8827b52d81483", size = 296359, upload_time = "2025-11-06T00:13:36.587Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6f/d1/385110a9ae86d91cc14c5282c61fe9f4dc41c0b9f7d423c6ad77038c4448/google_auth-2.43.0-py2.py3-none-any.whl", hash = "sha256:af628ba6fa493f75c7e9dbe9373d148ca9f4399b5ea29976519e0a3848eddd16", size = 223114, upload_time = "2025-11-06T00:13:35.209Z" }, +] + +[package.optional-dependencies] +requests = [ + { name = "requests" }, +] + +[[package]] +name = "google-genai" +version = "1.53.0" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +dependencies = [ + { name = "anyio" }, + { name = "google-auth", extra = ["requests"] }, + { name = "httpx" }, + { name = "pydantic" }, + { name = "requests" }, + { name = "tenacity" }, + { name = "typing-extensions" }, + { name = "websockets" }, +] +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/de/b3/36fbfde2e21e6d3bc67780b61da33632f495ab1be08076cf0a16af74098f/google_genai-1.53.0.tar.gz", hash = "sha256:938a26d22f3fd32c6eeeb4276ef204ef82884e63af9842ce3eac05ceb39cbd8d", size = 260102, upload_time = "2025-12-03T17:21:23.233Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/40/f2/97fefdd1ad1f3428321bac819ae7a83ccc59f6439616054736b7819fa56c/google_genai-1.53.0-py3-none-any.whl", hash = "sha256:65a3f99e5c03c372d872cda7419f5940e723374bb12a2f3ffd5e3e56e8eb2094", size = 262015, upload_time = "2025-12-03T17:21:21.934Z" }, +] + +[[package]] +name = "h11" +version = "0.16.0" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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.tuna.tsinghua.edu.cn/simple" } +dependencies = [ + { name = "certifi" }, + { name = "h11" }, +] +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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.tuna.tsinghua.edu.cn/simple" } +dependencies = [ + { name = "anyio" }, + { name = "certifi" }, + { name = "httpcore" }, + { name = "idna" }, +] +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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.11" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload_time = "2025-10-12T14:55:20.501Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload_time = "2025-10-12T14:55:18.883Z" }, +] + +[[package]] +name = "jieba" +version = "0.42.1" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/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.12.0" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/45/9d/e0660989c1370e25848bb4c52d061c71837239738ad937e83edca174c273/jiter-0.12.0.tar.gz", hash = "sha256:64dfcd7d5c168b38d3f9f8bba7fc639edb3418abcc74f22fdbe6b8938293f30b", size = 168294, upload_time = "2025-11-09T20:49:23.302Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3b/91/13cb9505f7be74a933f37da3af22e029f6ba64f5669416cb8b2774bc9682/jiter-0.12.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:e7acbaba9703d5de82a2c98ae6a0f59ab9770ab5af5fa35e43a303aee962cf65", size = 316652, upload_time = "2025-11-09T20:46:41.021Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/4e/76/4e9185e5d9bb4e482cf6dec6410d5f78dfeb374cfcecbbe9888d07c52daa/jiter-0.12.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:364f1a7294c91281260364222f535bc427f56d4de1d8ffd718162d21fbbd602e", size = 319829, upload_time = "2025-11-09T20:46:43.281Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/86/af/727de50995d3a153138139f259baae2379d8cb0522c0c00419957bc478a6/jiter-0.12.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:85ee4d25805d4fb23f0a5167a962ef8e002dbfb29c0989378488e32cf2744b62", size = 350568, upload_time = "2025-11-09T20:46:45.075Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6a/c1/d6e9f4b7a3d5ac63bcbdfddeb50b2dcfbdc512c86cffc008584fdc350233/jiter-0.12.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:796f466b7942107eb889c08433b6e31b9a7ed31daceaecf8af1be26fb26c0ca8", size = 369052, upload_time = "2025-11-09T20:46:46.818Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/eb/be/00824cd530f30ed73fa8a4f9f3890a705519e31ccb9e929f1e22062e7c76/jiter-0.12.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:35506cb71f47dba416694e67af996bbdefb8e3608f1f78799c2e1f9058b01ceb", size = 481585, upload_time = "2025-11-09T20:46:48.319Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/74/b6/2ad7990dff9504d4b5052eef64aa9574bd03d722dc7edced97aad0d47be7/jiter-0.12.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:726c764a90c9218ec9e4f99a33d6bf5ec169163f2ca0fc21b654e88c2abc0abc", size = 380541, upload_time = "2025-11-09T20:46:49.643Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b5/c7/f3c26ecbc1adbf1db0d6bba99192143d8fe8504729d9594542ecc4445784/jiter-0.12.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:baa47810c5565274810b726b0dc86d18dce5fd17b190ebdc3890851d7b2a0e74", size = 364423, upload_time = "2025-11-09T20:46:51.731Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/18/51/eac547bf3a2d7f7e556927278e14c56a0604b8cddae75815d5739f65f81d/jiter-0.12.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f8ec0259d3f26c62aed4d73b198c53e316ae11f0f69c8fbe6682c6dcfa0fcce2", size = 389958, upload_time = "2025-11-09T20:46:53.432Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2c/1f/9ca592e67175f2db156cff035e0d817d6004e293ee0c1d73692d38fcb596/jiter-0.12.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:79307d74ea83465b0152fa23e5e297149506435535282f979f18b9033c0bb025", size = 522084, upload_time = "2025-11-09T20:46:54.848Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/83/ff/597d9cdc3028f28224f53e1a9d063628e28b7a5601433e3196edda578cdd/jiter-0.12.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:cf6e6dd18927121fec86739f1a8906944703941d000f0639f3eb6281cc601dca", size = 513054, upload_time = "2025-11-09T20:46:56.487Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/24/6d/1970bce1351bd02e3afcc5f49e4f7ef3dabd7fb688f42be7e8091a5b809a/jiter-0.12.0-cp310-cp310-win32.whl", hash = "sha256:b6ae2aec8217327d872cbfb2c1694489057b9433afce447955763e6ab015b4c4", size = 206368, upload_time = "2025-11-09T20:46:58.638Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e3/6b/eb1eb505b2d86709b59ec06681a2b14a94d0941db091f044b9f0e16badc0/jiter-0.12.0-cp310-cp310-win_amd64.whl", hash = "sha256:c7f49ce90a71e44f7e1aa9e7ec415b9686bbc6a5961e57eab511015e6759bc11", size = 204847, upload_time = "2025-11-09T20:47:00.295Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/32/f9/eaca4633486b527ebe7e681c431f529b63fe2709e7c5242fc0f43f77ce63/jiter-0.12.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:d8f8a7e317190b2c2d60eb2e8aa835270b008139562d70fe732e1c0020ec53c9", size = 316435, upload_time = "2025-11-09T20:47:02.087Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/10/c1/40c9f7c22f5e6ff715f28113ebaba27ab85f9af2660ad6e1dd6425d14c19/jiter-0.12.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2218228a077e784c6c8f1a8e5d6b8cb1dea62ce25811c356364848554b2056cd", size = 320548, upload_time = "2025-11-09T20:47:03.409Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6b/1b/efbb68fe87e7711b00d2cfd1f26bb4bfc25a10539aefeaa7727329ffb9cb/jiter-0.12.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9354ccaa2982bf2188fd5f57f79f800ef622ec67beb8329903abf6b10da7d423", size = 351915, upload_time = "2025-11-09T20:47:05.171Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/15/2d/c06e659888c128ad1e838123d0638f0efad90cc30860cb5f74dd3f2fc0b3/jiter-0.12.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8f2607185ea89b4af9a604d4c7ec40e45d3ad03ee66998b031134bc510232bb7", size = 368966, upload_time = "2025-11-09T20:47:06.508Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6b/20/058db4ae5fb07cf6a4ab2e9b9294416f606d8e467fb74c2184b2a1eeacba/jiter-0.12.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3a585a5e42d25f2e71db5f10b171f5e5ea641d3aa44f7df745aa965606111cc2", size = 482047, upload_time = "2025-11-09T20:47:08.382Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/49/bb/dc2b1c122275e1de2eb12905015d61e8316b2f888bdaac34221c301495d6/jiter-0.12.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd9e21d34edff5a663c631f850edcb786719c960ce887a5661e9c828a53a95d9", size = 380835, upload_time = "2025-11-09T20:47:09.81Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/23/7d/38f9cd337575349de16da575ee57ddb2d5a64d425c9367f5ef9e4612e32e/jiter-0.12.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4a612534770470686cd5431478dc5a1b660eceb410abade6b1b74e320ca98de6", size = 364587, upload_time = "2025-11-09T20:47:11.529Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f0/a3/b13e8e61e70f0bb06085099c4e2462647f53cc2ca97614f7fedcaa2bb9f3/jiter-0.12.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:3985aea37d40a908f887b34d05111e0aae822943796ebf8338877fee2ab67725", size = 390492, upload_time = "2025-11-09T20:47:12.993Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/07/71/e0d11422ed027e21422f7bc1883c61deba2d9752b720538430c1deadfbca/jiter-0.12.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:b1207af186495f48f72529f8d86671903c8c10127cac6381b11dddc4aaa52df6", size = 522046, upload_time = "2025-11-09T20:47:14.6Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/9f/59/b968a9aa7102a8375dbbdfbd2aeebe563c7e5dddf0f47c9ef1588a97e224/jiter-0.12.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:ef2fb241de583934c9915a33120ecc06d94aa3381a134570f59eed784e87001e", size = 513392, upload_time = "2025-11-09T20:47:16.011Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ca/e4/7df62002499080dbd61b505c5cb351aa09e9959d176cac2aa8da6f93b13b/jiter-0.12.0-cp311-cp311-win32.whl", hash = "sha256:453b6035672fecce8007465896a25b28a6b59cfe8fbc974b2563a92f5a92a67c", size = 206096, upload_time = "2025-11-09T20:47:17.344Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/bb/60/1032b30ae0572196b0de0e87dce3b6c26a1eff71aad5fe43dee3082d32e0/jiter-0.12.0-cp311-cp311-win_amd64.whl", hash = "sha256:ca264b9603973c2ad9435c71a8ec8b49f8f715ab5ba421c85a51cde9887e421f", size = 204899, upload_time = "2025-11-09T20:47:19.365Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/49/d5/c145e526fccdb834063fb45c071df78b0cc426bbaf6de38b0781f45d956f/jiter-0.12.0-cp311-cp311-win_arm64.whl", hash = "sha256:cb00ef392e7d684f2754598c02c409f376ddcef857aae796d559e6cacc2d78a5", size = 188070, upload_time = "2025-11-09T20:47:20.75Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/92/c9/5b9f7b4983f1b542c64e84165075335e8a236fa9e2ea03a0c79780062be8/jiter-0.12.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:305e061fa82f4680607a775b2e8e0bcb071cd2205ac38e6ef48c8dd5ebe1cf37", size = 314449, upload_time = "2025-11-09T20:47:22.999Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/98/6e/e8efa0e78de00db0aee82c0cf9e8b3f2027efd7f8a71f859d8f4be8e98ef/jiter-0.12.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5c1860627048e302a528333c9307c818c547f214d8659b0705d2195e1a94b274", size = 319855, upload_time = "2025-11-09T20:47:24.779Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/20/26/894cd88e60b5d58af53bec5c6759d1292bd0b37a8b5f60f07abf7a63ae5f/jiter-0.12.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:df37577a4f8408f7e0ec3205d2a8f87672af8f17008358063a4d6425b6081ce3", size = 350171, upload_time = "2025-11-09T20:47:26.469Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f5/27/a7b818b9979ac31b3763d25f3653ec3a954044d5e9f5d87f2f247d679fd1/jiter-0.12.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:75fdd787356c1c13a4f40b43c2156276ef7a71eb487d98472476476d803fb2cf", size = 365590, upload_time = "2025-11-09T20:47:27.918Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ba/7e/e46195801a97673a83746170b17984aa8ac4a455746354516d02ca5541b4/jiter-0.12.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1eb5db8d9c65b112aacf14fcd0faae9913d07a8afea5ed06ccdd12b724e966a1", size = 479462, upload_time = "2025-11-09T20:47:29.654Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ca/75/f833bfb009ab4bd11b1c9406d333e3b4357709ed0570bb48c7c06d78c7dd/jiter-0.12.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:73c568cc27c473f82480abc15d1301adf333a7ea4f2e813d6a2c7d8b6ba8d0df", size = 378983, upload_time = "2025-11-09T20:47:31.026Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/71/b3/7a69d77943cc837d30165643db753471aff5df39692d598da880a6e51c24/jiter-0.12.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4321e8a3d868919bcb1abb1db550d41f2b5b326f72df29e53b2df8b006eb9403", size = 361328, upload_time = "2025-11-09T20:47:33.286Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b0/ac/a78f90caf48d65ba70d8c6efc6f23150bc39dc3389d65bbec2a95c7bc628/jiter-0.12.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:0a51bad79f8cc9cac2b4b705039f814049142e0050f30d91695a2d9a6611f126", size = 386740, upload_time = "2025-11-09T20:47:34.703Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/39/b6/5d31c2cc8e1b6a6bcf3c5721e4ca0a3633d1ab4754b09bc7084f6c4f5327/jiter-0.12.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:2a67b678f6a5f1dd6c36d642d7db83e456bc8b104788262aaefc11a22339f5a9", size = 520875, upload_time = "2025-11-09T20:47:36.058Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/30/b5/4df540fae4e9f68c54b8dab004bd8c943a752f0b00efd6e7d64aa3850339/jiter-0.12.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:efe1a211fe1fd14762adea941e3cfd6c611a136e28da6c39272dbb7a1bbe6a86", size = 511457, upload_time = "2025-11-09T20:47:37.932Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/07/65/86b74010e450a1a77b2c1aabb91d4a91dd3cd5afce99f34d75fd1ac64b19/jiter-0.12.0-cp312-cp312-win32.whl", hash = "sha256:d779d97c834b4278276ec703dc3fc1735fca50af63eb7262f05bdb4e62203d44", size = 204546, upload_time = "2025-11-09T20:47:40.47Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/1c/c7/6659f537f9562d963488e3e55573498a442503ced01f7e169e96a6110383/jiter-0.12.0-cp312-cp312-win_amd64.whl", hash = "sha256:e8269062060212b373316fe69236096aaf4c49022d267c6736eebd66bbbc60bb", size = 205196, upload_time = "2025-11-09T20:47:41.794Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/21/f4/935304f5169edadfec7f9c01eacbce4c90bb9a82035ac1de1f3bd2d40be6/jiter-0.12.0-cp312-cp312-win_arm64.whl", hash = "sha256:06cb970936c65de926d648af0ed3d21857f026b1cf5525cb2947aa5e01e05789", size = 186100, upload_time = "2025-11-09T20:47:43.007Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3d/a6/97209693b177716e22576ee1161674d1d58029eb178e01866a0422b69224/jiter-0.12.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:6cc49d5130a14b732e0612bc76ae8db3b49898732223ef8b7599aa8d9810683e", size = 313658, upload_time = "2025-11-09T20:47:44.424Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/06/4d/125c5c1537c7d8ee73ad3d530a442d6c619714b95027143f1b61c0b4dfe0/jiter-0.12.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:37f27a32ce36364d2fa4f7fdc507279db604d27d239ea2e044c8f148410defe1", size = 318605, upload_time = "2025-11-09T20:47:45.973Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/99/bf/a840b89847885064c41a5f52de6e312e91fa84a520848ee56c97e4fa0205/jiter-0.12.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bbc0944aa3d4b4773e348cda635252824a78f4ba44328e042ef1ff3f6080d1cf", size = 349803, upload_time = "2025-11-09T20:47:47.535Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8a/88/e63441c28e0db50e305ae23e19c1d8fae012d78ed55365da392c1f34b09c/jiter-0.12.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:da25c62d4ee1ffbacb97fac6dfe4dcd6759ebdc9015991e92a6eae5816287f44", size = 365120, upload_time = "2025-11-09T20:47:49.284Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0a/7c/49b02714af4343970eb8aca63396bc1c82fa01197dbb1e9b0d274b550d4e/jiter-0.12.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:048485c654b838140b007390b8182ba9774621103bd4d77c9c3f6f117474ba45", size = 479918, upload_time = "2025-11-09T20:47:50.807Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/69/ba/0a809817fdd5a1db80490b9150645f3aae16afad166960bcd562be194f3b/jiter-0.12.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:635e737fbb7315bef0037c19b88b799143d2d7d3507e61a76751025226b3ac87", size = 379008, upload_time = "2025-11-09T20:47:52.211Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5f/c3/c9fc0232e736c8877d9e6d83d6eeb0ba4e90c6c073835cc2e8f73fdeef51/jiter-0.12.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4e017c417b1ebda911bd13b1e40612704b1f5420e30695112efdbed8a4b389ed", size = 361785, upload_time = "2025-11-09T20:47:53.512Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/96/61/61f69b7e442e97ca6cd53086ddc1cf59fb830549bc72c0a293713a60c525/jiter-0.12.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:89b0bfb8b2bf2351fba36bb211ef8bfceba73ef58e7f0c68fb67b5a2795ca2f9", size = 386108, upload_time = "2025-11-09T20:47:54.893Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e9/2e/76bb3332f28550c8f1eba3bf6e5efe211efda0ddbbaf24976bc7078d42a5/jiter-0.12.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:f5aa5427a629a824a543672778c9ce0c5e556550d1569bb6ea28a85015287626", size = 519937, upload_time = "2025-11-09T20:47:56.253Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/84/d6/fa96efa87dc8bff2094fb947f51f66368fa56d8d4fc9e77b25d7fbb23375/jiter-0.12.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:ed53b3d6acbcb0fd0b90f20c7cb3b24c357fe82a3518934d4edfa8c6898e498c", size = 510853, upload_time = "2025-11-09T20:47:58.32Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8a/28/93f67fdb4d5904a708119a6ab58a8f1ec226ff10a94a282e0215402a8462/jiter-0.12.0-cp313-cp313-win32.whl", hash = "sha256:4747de73d6b8c78f2e253a2787930f4fffc68da7fa319739f57437f95963c4de", size = 204699, upload_time = "2025-11-09T20:47:59.686Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c4/1f/30b0eb087045a0abe2a5c9c0c0c8da110875a1d3be83afd4a9a4e548be3c/jiter-0.12.0-cp313-cp313-win_amd64.whl", hash = "sha256:e25012eb0c456fcc13354255d0338cd5397cce26c77b2832b3c4e2e255ea5d9a", size = 204258, upload_time = "2025-11-09T20:48:01.01Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2c/f4/2b4daf99b96bce6fc47971890b14b2a36aef88d7beb9f057fafa032c6141/jiter-0.12.0-cp313-cp313-win_arm64.whl", hash = "sha256:c97b92c54fe6110138c872add030a1f99aea2401ddcdaa21edf74705a646dd60", size = 185503, upload_time = "2025-11-09T20:48:02.35Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/39/ca/67bb15a7061d6fe20b9b2a2fd783e296a1e0f93468252c093481a2f00efa/jiter-0.12.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:53839b35a38f56b8be26a7851a48b89bc47e5d88e900929df10ed93b95fea3d6", size = 317965, upload_time = "2025-11-09T20:48:03.783Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/18/af/1788031cd22e29c3b14bc6ca80b16a39a0b10e611367ffd480c06a259831/jiter-0.12.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:94f669548e55c91ab47fef8bddd9c954dab1938644e715ea49d7e117015110a4", size = 345831, upload_time = "2025-11-09T20:48:05.55Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/05/17/710bf8472d1dff0d3caf4ced6031060091c1320f84ee7d5dcbed1f352417/jiter-0.12.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:351d54f2b09a41600ffea43d081522d792e81dcfb915f6d2d242744c1cc48beb", size = 361272, upload_time = "2025-11-09T20:48:06.951Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fb/f1/1dcc4618b59761fef92d10bcbb0b038b5160be653b003651566a185f1a5c/jiter-0.12.0-cp313-cp313t-win_amd64.whl", hash = "sha256:2a5e90604620f94bf62264e7c2c038704d38217b7465b863896c6d7c902b06c7", size = 204604, upload_time = "2025-11-09T20:48:08.328Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d9/32/63cb1d9f1c5c6632a783c0052cde9ef7ba82688f7065e2f0d5f10a7e3edb/jiter-0.12.0-cp313-cp313t-win_arm64.whl", hash = "sha256:88ef757017e78d2860f96250f9393b7b577b06a956ad102c29c8237554380db3", size = 185628, upload_time = "2025-11-09T20:48:09.572Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a8/99/45c9f0dbe4a1416b2b9a8a6d1236459540f43d7fb8883cff769a8db0612d/jiter-0.12.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:c46d927acd09c67a9fb1416df45c5a04c27e83aae969267e98fba35b74e99525", size = 312478, upload_time = "2025-11-09T20:48:10.898Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/4c/a7/54ae75613ba9e0f55fcb0bc5d1f807823b5167cc944e9333ff322e9f07dd/jiter-0.12.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:774ff60b27a84a85b27b88cd5583899c59940bcc126caca97eb2a9df6aa00c49", size = 318706, upload_time = "2025-11-09T20:48:12.266Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/59/31/2aa241ad2c10774baf6c37f8b8e1f39c07db358f1329f4eb40eba179c2a2/jiter-0.12.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c5433fab222fb072237df3f637d01b81f040a07dcac1cb4a5c75c7aa9ed0bef1", size = 351894, upload_time = "2025-11-09T20:48:13.673Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/54/4f/0f2759522719133a9042781b18cc94e335b6d290f5e2d3e6899d6af933e3/jiter-0.12.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f8c593c6e71c07866ec6bfb790e202a833eeec885022296aff6b9e0b92d6a70e", size = 365714, upload_time = "2025-11-09T20:48:15.083Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/dc/6f/806b895f476582c62a2f52c453151edd8a0fde5411b0497baaa41018e878/jiter-0.12.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:90d32894d4c6877a87ae00c6b915b609406819dce8bc0d4e962e4de2784e567e", size = 478989, upload_time = "2025-11-09T20:48:16.706Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/86/6c/012d894dc6e1033acd8db2b8346add33e413ec1c7c002598915278a37f79/jiter-0.12.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:798e46eed9eb10c3adbbacbd3bdb5ecd4cf7064e453d00dbef08802dae6937ff", size = 378615, upload_time = "2025-11-09T20:48:18.614Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/87/30/d718d599f6700163e28e2c71c0bbaf6dace692e7df2592fd793ac9276717/jiter-0.12.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b3f1368f0a6719ea80013a4eb90ba72e75d7ea67cfc7846db2ca504f3df0169a", size = 364745, upload_time = "2025-11-09T20:48:20.117Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8f/85/315b45ce4b6ddc7d7fceca24068543b02bdc8782942f4ee49d652e2cc89f/jiter-0.12.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:65f04a9d0b4406f7e51279710b27484af411896246200e461d80d3ba0caa901a", size = 386502, upload_time = "2025-11-09T20:48:21.543Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/74/0b/ce0434fb40c5b24b368fe81b17074d2840748b4952256bab451b72290a49/jiter-0.12.0-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:fd990541982a24281d12b67a335e44f117e4c6cbad3c3b75c7dea68bf4ce3a67", size = 519845, upload_time = "2025-11-09T20:48:22.964Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e8/a3/7a7a4488ba052767846b9c916d208b3ed114e3eb670ee984e4c565b9cf0d/jiter-0.12.0-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:b111b0e9152fa7df870ecaebb0bd30240d9f7fff1f2003bcb4ed0f519941820b", size = 510701, upload_time = "2025-11-09T20:48:24.483Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c3/16/052ffbf9d0467b70af24e30f91e0579e13ded0c17bb4a8eb2aed3cb60131/jiter-0.12.0-cp314-cp314-win32.whl", hash = "sha256:a78befb9cc0a45b5a5a0d537b06f8544c2ebb60d19d02c41ff15da28a9e22d42", size = 205029, upload_time = "2025-11-09T20:48:25.749Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e4/18/3cf1f3f0ccc789f76b9a754bdb7a6977e5d1d671ee97a9e14f7eb728d80e/jiter-0.12.0-cp314-cp314-win_amd64.whl", hash = "sha256:e1fe01c082f6aafbe5c8faf0ff074f38dfb911d53f07ec333ca03f8f6226debf", size = 204960, upload_time = "2025-11-09T20:48:27.415Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/02/68/736821e52ecfdeeb0f024b8ab01b5a229f6b9293bbdb444c27efade50b0f/jiter-0.12.0-cp314-cp314-win_arm64.whl", hash = "sha256:d72f3b5a432a4c546ea4bedc84cce0c3404874f1d1676260b9c7f048a9855451", size = 185529, upload_time = "2025-11-09T20:48:29.125Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/30/61/12ed8ee7a643cce29ac97c2281f9ce3956eb76b037e88d290f4ed0d41480/jiter-0.12.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:e6ded41aeba3603f9728ed2b6196e4df875348ab97b28fc8afff115ed42ba7a7", size = 318974, upload_time = "2025-11-09T20:48:30.87Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2d/c6/f3041ede6d0ed5e0e79ff0de4c8f14f401bbf196f2ef3971cdbe5fd08d1d/jiter-0.12.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a947920902420a6ada6ad51892082521978e9dd44a802663b001436e4b771684", size = 345932, upload_time = "2025-11-09T20:48:32.658Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d5/5d/4d94835889edd01ad0e2dbfc05f7bdfaed46292e7b504a6ac7839aa00edb/jiter-0.12.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:add5e227e0554d3a52cf390a7635edaffdf4f8fce4fdbcef3cc2055bb396a30c", size = 367243, upload_time = "2025-11-09T20:48:34.093Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fd/76/0051b0ac2816253a99d27baf3dda198663aff882fa6ea7deeb94046da24e/jiter-0.12.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3f9b1cda8fcb736250d7e8711d4580ebf004a46771432be0ae4796944b5dfa5d", size = 479315, upload_time = "2025-11-09T20:48:35.507Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/70/ae/83f793acd68e5cb24e483f44f482a1a15601848b9b6f199dacb970098f77/jiter-0.12.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:deeb12a2223fe0135c7ff1356a143d57f95bbf1f4a66584f1fc74df21d86b993", size = 380714, upload_time = "2025-11-09T20:48:40.014Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b1/5e/4808a88338ad2c228b1126b93fcd8ba145e919e886fe910d578230dabe3b/jiter-0.12.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c596cc0f4cb574877550ce4ecd51f8037469146addd676d7c1a30ebe6391923f", size = 365168, upload_time = "2025-11-09T20:48:41.462Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0c/d4/04619a9e8095b42aef436b5aeb4c0282b4ff1b27d1db1508df9f5dc82750/jiter-0.12.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5ab4c823b216a4aeab3fdbf579c5843165756bd9ad87cc6b1c65919c4715f783", size = 387893, upload_time = "2025-11-09T20:48:42.921Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/17/ea/d3c7e62e4546fdc39197fa4a4315a563a89b95b6d54c0d25373842a59cbe/jiter-0.12.0-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:e427eee51149edf962203ff8db75a7514ab89be5cb623fb9cea1f20b54f1107b", size = 520828, upload_time = "2025-11-09T20:48:44.278Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/cc/0b/c6d3562a03fd767e31cb119d9041ea7958c3c80cb3d753eafb19b3b18349/jiter-0.12.0-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:edb868841f84c111255ba5e80339d386d937ec1fdce419518ce1bd9370fac5b6", size = 511009, upload_time = "2025-11-09T20:48:45.726Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/aa/51/2cb4468b3448a8385ebcd15059d325c9ce67df4e2758d133ab9442b19834/jiter-0.12.0-cp314-cp314t-win32.whl", hash = "sha256:8bbcfe2791dfdb7c5e48baf646d37a6a3dcb5a97a032017741dea9f817dca183", size = 205110, upload_time = "2025-11-09T20:48:47.033Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b2/c5/ae5ec83dec9c2d1af805fd5fe8f74ebded9c8670c5210ec7820ce0dbeb1e/jiter-0.12.0-cp314-cp314t-win_amd64.whl", hash = "sha256:2fa940963bf02e1d8226027ef461e36af472dea85d36054ff835aeed944dd873", size = 205223, upload_time = "2025-11-09T20:48:49.076Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/97/9a/3c5391907277f0e55195550cf3fa8e293ae9ee0c00fb402fec1e38c0c82f/jiter-0.12.0-cp314-cp314t-win_arm64.whl", hash = "sha256:506c9708dd29b27288f9f8f1140c3cb0e3d8ddb045956d7757b1fa0e0f39a473", size = 185564, upload_time = "2025-11-09T20:48:50.376Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fe/54/5339ef1ecaa881c6948669956567a64d2670941925f245c434f494ffb0e5/jiter-0.12.0-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:4739a4657179ebf08f85914ce50332495811004cc1747852e8b2041ed2aab9b8", size = 311144, upload_time = "2025-11-09T20:49:10.503Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/27/74/3446c652bffbd5e81ab354e388b1b5fc1d20daac34ee0ed11ff096b1b01a/jiter-0.12.0-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:41da8def934bf7bec16cb24bd33c0ca62126d2d45d81d17b864bd5ad721393c3", size = 305877, upload_time = "2025-11-09T20:49:12.269Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a1/f4/ed76ef9043450f57aac2d4fbeb27175aa0eb9c38f833be6ef6379b3b9a86/jiter-0.12.0-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9c44ee814f499c082e69872d426b624987dbc5943ab06e9bbaa4f81989fdb79e", size = 340419, upload_time = "2025-11-09T20:49:13.803Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/21/01/857d4608f5edb0664aa791a3d45702e1a5bcfff9934da74035e7b9803846/jiter-0.12.0-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cd2097de91cf03eaa27b3cbdb969addf83f0179c6afc41bbc4513705e013c65d", size = 347212, upload_time = "2025-11-09T20:49:15.643Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/cb/f5/12efb8ada5f5c9edc1d4555fe383c1fb2eac05ac5859258a72d61981d999/jiter-0.12.0-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:e8547883d7b96ef2e5fe22b88f8a4c8725a56e7f4abafff20fd5272d634c7ecb", size = 309974, upload_time = "2025-11-09T20:49:17.187Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/85/15/d6eb3b770f6a0d332675141ab3962fd4a7c270ede3515d9f3583e1d28276/jiter-0.12.0-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:89163163c0934854a668ed783a2546a0617f71706a2551a4a0666d91ab365d6b", size = 304233, upload_time = "2025-11-09T20:49:18.734Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8c/3e/e7e06743294eea2cf02ced6aa0ff2ad237367394e37a0e2b4a1108c67a36/jiter-0.12.0-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d96b264ab7d34bbb2312dedc47ce07cd53f06835eacbc16dde3761f47c3a9e7f", size = 338537, upload_time = "2025-11-09T20:49:20.317Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2f/9c/6753e6522b8d0ef07d3a3d239426669e984fb0eba15a315cdbc1253904e4/jiter-0.12.0-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c24e864cb30ab82311c6425655b0cdab0a98c5d973b065c66a3f020740c2324c", size = 346110, upload_time = "2025-11-09T20:49:21.817Z" }, +] + +[[package]] +name = "json-repair" +version = "0.54.2" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ff/05/9fbcd5ffab9c41455e7d80af65a90876718b8ea2fb4525e187ab11836dd4/json_repair-0.54.2.tar.gz", hash = "sha256:4b6b62ce17f1a505b220fa4aadba1fc37dc9c221544f158471efe3775620bad6", size = 38575, upload_time = "2025-11-25T19:31:22.768Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/53/3a/1b4df9adcd69fee9c9e4b439c13e8c866f2fae520054aede7030b2278be9/json_repair-0.54.2-py3-none-any.whl", hash = "sha256:be51cce5dca97e0c24ebdf61a1ede2449a8a7666012de99467bb7b0afb35179b", size = 29322, upload_time = "2025-11-25T19:31:21.492Z" }, +] + +[[package]] +name = "kiwisolver" +version = "1.4.9" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5c/3c/85844f1b0feb11ee581ac23fe5fce65cd049a200c1446708cc1b7f922875/kiwisolver-1.4.9.tar.gz", hash = "sha256:c3b22c26c6fd6811b0ae8363b95ca8ce4ea3c202d3d0975b2914310ceb1bcc4d", size = 97564, upload_time = "2025-08-10T21:27:49.279Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c6/5d/8ce64e36d4e3aac5ca96996457dcf33e34e6051492399a3f1fec5657f30b/kiwisolver-1.4.9-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:b4b4d74bda2b8ebf4da5bd42af11d02d04428b2c32846e4c2c93219df8a7987b", size = 124159, upload_time = "2025-08-10T21:25:35.472Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/96/1e/22f63ec454874378175a5f435d6ea1363dd33fb2af832c6643e4ccea0dc8/kiwisolver-1.4.9-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:fb3b8132019ea572f4611d770991000d7f58127560c4889729248eb5852a102f", size = 66578, upload_time = "2025-08-10T21:25:36.73Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/41/4c/1925dcfff47a02d465121967b95151c82d11027d5ec5242771e580e731bd/kiwisolver-1.4.9-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:84fd60810829c27ae375114cd379da1fa65e6918e1da405f356a775d49a62bcf", size = 65312, upload_time = "2025-08-10T21:25:37.658Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d4/42/0f333164e6307a0687d1eb9ad256215aae2f4bd5d28f4653d6cd319a3ba3/kiwisolver-1.4.9-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:b78efa4c6e804ecdf727e580dbb9cba85624d2e1c6b5cb059c66290063bd99a9", size = 1628458, upload_time = "2025-08-10T21:25:39.067Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/86/b6/2dccb977d651943995a90bfe3495c2ab2ba5cd77093d9f2318a20c9a6f59/kiwisolver-1.4.9-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d4efec7bcf21671db6a3294ff301d2fc861c31faa3c8740d1a94689234d1b415", size = 1225640, upload_time = "2025-08-10T21:25:40.489Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/50/2b/362ebd3eec46c850ccf2bfe3e30f2fc4c008750011f38a850f088c56a1c6/kiwisolver-1.4.9-cp310-cp310-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:90f47e70293fc3688b71271100a1a5453aa9944a81d27ff779c108372cf5567b", size = 1244074, upload_time = "2025-08-10T21:25:42.221Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6f/bb/f09a1e66dab8984773d13184a10a29fe67125337649d26bdef547024ed6b/kiwisolver-1.4.9-cp310-cp310-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8fdca1def57a2e88ef339de1737a1449d6dbf5fab184c54a1fca01d541317154", size = 1293036, upload_time = "2025-08-10T21:25:43.801Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ea/01/11ecf892f201cafda0f68fa59212edaea93e96c37884b747c181303fccd1/kiwisolver-1.4.9-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:9cf554f21be770f5111a1690d42313e140355e687e05cf82cb23d0a721a64a48", size = 2175310, upload_time = "2025-08-10T21:25:45.045Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/7f/5f/bfe11d5b934f500cc004314819ea92427e6e5462706a498c1d4fc052e08f/kiwisolver-1.4.9-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:fc1795ac5cd0510207482c3d1d3ed781143383b8cfd36f5c645f3897ce066220", size = 2270943, upload_time = "2025-08-10T21:25:46.393Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3d/de/259f786bf71f1e03e73d87e2db1a9a3bcab64d7b4fd780167123161630ad/kiwisolver-1.4.9-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:ccd09f20ccdbbd341b21a67ab50a119b64a403b09288c27481575105283c1586", size = 2440488, upload_time = "2025-08-10T21:25:48.074Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/1b/76/c989c278faf037c4d3421ec07a5c452cd3e09545d6dae7f87c15f54e4edf/kiwisolver-1.4.9-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:540c7c72324d864406a009d72f5d6856f49693db95d1fbb46cf86febef873634", size = 2246787, upload_time = "2025-08-10T21:25:49.442Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a2/55/c2898d84ca440852e560ca9f2a0d28e6e931ac0849b896d77231929900e7/kiwisolver-1.4.9-cp310-cp310-win_amd64.whl", hash = "sha256:ede8c6d533bc6601a47ad4046080d36b8fc99f81e6f1c17b0ac3c2dc91ac7611", size = 73730, upload_time = "2025-08-10T21:25:51.102Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e8/09/486d6ac523dd33b80b368247f238125d027964cfacb45c654841e88fb2ae/kiwisolver-1.4.9-cp310-cp310-win_arm64.whl", hash = "sha256:7b4da0d01ac866a57dd61ac258c5607b4cd677f63abaec7b148354d2b2cdd536", size = 65036, upload_time = "2025-08-10T21:25:52.063Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6f/ab/c80b0d5a9d8a1a65f4f815f2afff9798b12c3b9f31f1d304dd233dd920e2/kiwisolver-1.4.9-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:eb14a5da6dc7642b0f3a18f13654847cd8b7a2550e2645a5bda677862b03ba16", size = 124167, upload_time = "2025-08-10T21:25:53.403Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a0/c0/27fe1a68a39cf62472a300e2879ffc13c0538546c359b86f149cc19f6ac3/kiwisolver-1.4.9-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:39a219e1c81ae3b103643d2aedb90f1ef22650deb266ff12a19e7773f3e5f089", size = 66579, upload_time = "2025-08-10T21:25:54.79Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/31/a2/a12a503ac1fd4943c50f9822678e8015a790a13b5490354c68afb8489814/kiwisolver-1.4.9-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2405a7d98604b87f3fc28b1716783534b1b4b8510d8142adca34ee0bc3c87543", size = 65309, upload_time = "2025-08-10T21:25:55.76Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/66/e1/e533435c0be77c3f64040d68d7a657771194a63c279f55573188161e81ca/kiwisolver-1.4.9-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:dc1ae486f9abcef254b5618dfb4113dd49f94c68e3e027d03cf0143f3f772b61", size = 1435596, upload_time = "2025-08-10T21:25:56.861Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/67/1e/51b73c7347f9aabdc7215aa79e8b15299097dc2f8e67dee2b095faca9cb0/kiwisolver-1.4.9-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8a1f570ce4d62d718dce3f179ee78dac3b545ac16c0c04bb363b7607a949c0d1", size = 1246548, upload_time = "2025-08-10T21:25:58.246Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/21/aa/72a1c5d1e430294f2d32adb9542719cfb441b5da368d09d268c7757af46c/kiwisolver-1.4.9-cp311-cp311-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cb27e7b78d716c591e88e0a09a2139c6577865d7f2e152488c2cc6257f460872", size = 1263618, upload_time = "2025-08-10T21:25:59.857Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a3/af/db1509a9e79dbf4c260ce0cfa3903ea8945f6240e9e59d1e4deb731b1a40/kiwisolver-1.4.9-cp311-cp311-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:15163165efc2f627eb9687ea5f3a28137217d217ac4024893d753f46bce9de26", size = 1317437, upload_time = "2025-08-10T21:26:01.105Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e0/f2/3ea5ee5d52abacdd12013a94130436e19969fa183faa1e7c7fbc89e9a42f/kiwisolver-1.4.9-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:bdee92c56a71d2b24c33a7d4c2856bd6419d017e08caa7802d2963870e315028", size = 2195742, upload_time = "2025-08-10T21:26:02.675Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6f/9b/1efdd3013c2d9a2566aa6a337e9923a00590c516add9a1e89a768a3eb2fc/kiwisolver-1.4.9-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:412f287c55a6f54b0650bd9b6dce5aceddb95864a1a90c87af16979d37c89771", size = 2290810, upload_time = "2025-08-10T21:26:04.009Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fb/e5/cfdc36109ae4e67361f9bc5b41323648cb24a01b9ade18784657e022e65f/kiwisolver-1.4.9-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:2c93f00dcba2eea70af2be5f11a830a742fe6b579a1d4e00f47760ef13be247a", size = 2461579, upload_time = "2025-08-10T21:26:05.317Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/62/86/b589e5e86c7610842213994cdea5add00960076bef4ae290c5fa68589cac/kiwisolver-1.4.9-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f117e1a089d9411663a3207ba874f31be9ac8eaa5b533787024dc07aeb74f464", size = 2268071, upload_time = "2025-08-10T21:26:06.686Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3b/c6/f8df8509fd1eee6c622febe54384a96cfaf4d43bf2ccec7a0cc17e4715c9/kiwisolver-1.4.9-cp311-cp311-win_amd64.whl", hash = "sha256:be6a04e6c79819c9a8c2373317d19a96048e5a3f90bec587787e86a1153883c2", size = 73840, upload_time = "2025-08-10T21:26:07.94Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e2/2d/16e0581daafd147bc11ac53f032a2b45eabac897f42a338d0a13c1e5c436/kiwisolver-1.4.9-cp311-cp311-win_arm64.whl", hash = "sha256:0ae37737256ba2de764ddc12aed4956460277f00c4996d51a197e72f62f5eec7", size = 65159, upload_time = "2025-08-10T21:26:09.048Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/86/c9/13573a747838aeb1c76e3267620daa054f4152444d1f3d1a2324b78255b5/kiwisolver-1.4.9-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ac5a486ac389dddcc5bef4f365b6ae3ffff2c433324fb38dd35e3fab7c957999", size = 123686, upload_time = "2025-08-10T21:26:10.034Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/51/ea/2ecf727927f103ffd1739271ca19c424d0e65ea473fbaeea1c014aea93f6/kiwisolver-1.4.9-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f2ba92255faa7309d06fe44c3a4a97efe1c8d640c2a79a5ef728b685762a6fd2", size = 66460, upload_time = "2025-08-10T21:26:11.083Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5b/5a/51f5464373ce2aeb5194508298a508b6f21d3867f499556263c64c621914/kiwisolver-1.4.9-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4a2899935e724dd1074cb568ce7ac0dce28b2cd6ab539c8e001a8578eb106d14", size = 64952, upload_time = "2025-08-10T21:26:12.058Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/70/90/6d240beb0f24b74371762873e9b7f499f1e02166a2d9c5801f4dbf8fa12e/kiwisolver-1.4.9-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f6008a4919fdbc0b0097089f67a1eb55d950ed7e90ce2cc3e640abadd2757a04", size = 1474756, upload_time = "2025-08-10T21:26:13.096Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/12/42/f36816eaf465220f683fb711efdd1bbf7a7005a2473d0e4ed421389bd26c/kiwisolver-1.4.9-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:67bb8b474b4181770f926f7b7d2f8c0248cbcb78b660fdd41a47054b28d2a752", size = 1276404, upload_time = "2025-08-10T21:26:14.457Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2e/64/bc2de94800adc830c476dce44e9b40fd0809cddeef1fde9fcf0f73da301f/kiwisolver-1.4.9-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2327a4a30d3ee07d2fbe2e7933e8a37c591663b96ce42a00bc67461a87d7df77", size = 1294410, upload_time = "2025-08-10T21:26:15.73Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5f/42/2dc82330a70aa8e55b6d395b11018045e58d0bb00834502bf11509f79091/kiwisolver-1.4.9-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7a08b491ec91b1d5053ac177afe5290adacf1f0f6307d771ccac5de30592d198", size = 1343631, upload_time = "2025-08-10T21:26:17.045Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/22/fd/f4c67a6ed1aab149ec5a8a401c323cee7a1cbe364381bb6c9c0d564e0e20/kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d8fc5c867c22b828001b6a38d2eaeb88160bf5783c6cb4a5e440efc981ce286d", size = 2224963, upload_time = "2025-08-10T21:26:18.737Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/45/aa/76720bd4cb3713314677d9ec94dcc21ced3f1baf4830adde5bb9b2430a5f/kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:3b3115b2581ea35bb6d1f24a4c90af37e5d9b49dcff267eeed14c3893c5b86ab", size = 2321295, upload_time = "2025-08-10T21:26:20.11Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/80/19/d3ec0d9ab711242f56ae0dc2fc5d70e298bb4a1f9dfab44c027668c673a1/kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:858e4c22fb075920b96a291928cb7dea5644e94c0ee4fcd5af7e865655e4ccf2", size = 2487987, upload_time = "2025-08-10T21:26:21.49Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/39/e9/61e4813b2c97e86b6fdbd4dd824bf72d28bcd8d4849b8084a357bc0dd64d/kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ed0fecd28cc62c54b262e3736f8bb2512d8dcfdc2bcf08be5f47f96bf405b145", size = 2291817, upload_time = "2025-08-10T21:26:22.812Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a0/41/85d82b0291db7504da3c2defe35c9a8a5c9803a730f297bd823d11d5fb77/kiwisolver-1.4.9-cp312-cp312-win_amd64.whl", hash = "sha256:f68208a520c3d86ea51acf688a3e3002615a7f0238002cccc17affecc86a8a54", size = 73895, upload_time = "2025-08-10T21:26:24.37Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e2/92/5f3068cf15ee5cb624a0c7596e67e2a0bb2adee33f71c379054a491d07da/kiwisolver-1.4.9-cp312-cp312-win_arm64.whl", hash = "sha256:2c1a4f57df73965f3f14df20b80ee29e6a7930a57d2d9e8491a25f676e197c60", size = 64992, upload_time = "2025-08-10T21:26:25.732Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/31/c1/c2686cda909742ab66c7388e9a1a8521a59eb89f8bcfbee28fc980d07e24/kiwisolver-1.4.9-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a5d0432ccf1c7ab14f9949eec60c5d1f924f17c037e9f8b33352fa05799359b8", size = 123681, upload_time = "2025-08-10T21:26:26.725Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ca/f0/f44f50c9f5b1a1860261092e3bc91ecdc9acda848a8b8c6abfda4a24dd5c/kiwisolver-1.4.9-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:efb3a45b35622bb6c16dbfab491a8f5a391fe0e9d45ef32f4df85658232ca0e2", size = 66464, upload_time = "2025-08-10T21:26:27.733Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2d/7a/9d90a151f558e29c3936b8a47ac770235f436f2120aca41a6d5f3d62ae8d/kiwisolver-1.4.9-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1a12cf6398e8a0a001a059747a1cbf24705e18fe413bc22de7b3d15c67cffe3f", size = 64961, upload_time = "2025-08-10T21:26:28.729Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e9/e9/f218a2cb3a9ffbe324ca29a9e399fa2d2866d7f348ec3a88df87fc248fc5/kiwisolver-1.4.9-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b67e6efbf68e077dd71d1a6b37e43e1a99d0bff1a3d51867d45ee8908b931098", size = 1474607, upload_time = "2025-08-10T21:26:29.798Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d9/28/aac26d4c882f14de59041636292bc838db8961373825df23b8eeb807e198/kiwisolver-1.4.9-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5656aa670507437af0207645273ccdfee4f14bacd7f7c67a4306d0dcaeaf6eed", size = 1276546, upload_time = "2025-08-10T21:26:31.401Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8b/ad/8bfc1c93d4cc565e5069162f610ba2f48ff39b7de4b5b8d93f69f30c4bed/kiwisolver-1.4.9-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:bfc08add558155345129c7803b3671cf195e6a56e7a12f3dde7c57d9b417f525", size = 1294482, upload_time = "2025-08-10T21:26:32.721Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/da/f1/6aca55ff798901d8ce403206d00e033191f63d82dd708a186e0ed2067e9c/kiwisolver-1.4.9-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:40092754720b174e6ccf9e845d0d8c7d8e12c3d71e7fc35f55f3813e96376f78", size = 1343720, upload_time = "2025-08-10T21:26:34.032Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d1/91/eed031876c595c81d90d0f6fc681ece250e14bf6998c3d7c419466b523b7/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:497d05f29a1300d14e02e6441cf0f5ee81c1ff5a304b0d9fb77423974684e08b", size = 2224907, upload_time = "2025-08-10T21:26:35.824Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e9/ec/4d1925f2e49617b9cca9c34bfa11adefad49d00db038e692a559454dfb2e/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:bdd1a81a1860476eb41ac4bc1e07b3f07259e6d55bbf739b79c8aaedcf512799", size = 2321334, upload_time = "2025-08-10T21:26:37.534Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/43/cb/450cd4499356f68802750c6ddc18647b8ea01ffa28f50d20598e0befe6e9/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:e6b93f13371d341afee3be9f7c5964e3fe61d5fa30f6a30eb49856935dfe4fc3", size = 2488313, upload_time = "2025-08-10T21:26:39.191Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/71/67/fc76242bd99f885651128a5d4fa6083e5524694b7c88b489b1b55fdc491d/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d75aa530ccfaa593da12834b86a0724f58bff12706659baa9227c2ccaa06264c", size = 2291970, upload_time = "2025-08-10T21:26:40.828Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/75/bd/f1a5d894000941739f2ae1b65a32892349423ad49c2e6d0771d0bad3fae4/kiwisolver-1.4.9-cp313-cp313-win_amd64.whl", hash = "sha256:dd0a578400839256df88c16abddf9ba14813ec5f21362e1fe65022e00c883d4d", size = 73894, upload_time = "2025-08-10T21:26:42.33Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/95/38/dce480814d25b99a391abbddadc78f7c117c6da34be68ca8b02d5848b424/kiwisolver-1.4.9-cp313-cp313-win_arm64.whl", hash = "sha256:d4188e73af84ca82468f09cadc5ac4db578109e52acb4518d8154698d3a87ca2", size = 64995, upload_time = "2025-08-10T21:26:43.889Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e2/37/7d218ce5d92dadc5ebdd9070d903e0c7cf7edfe03f179433ac4d13ce659c/kiwisolver-1.4.9-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:5a0f2724dfd4e3b3ac5a82436a8e6fd16baa7d507117e4279b660fe8ca38a3a1", size = 126510, upload_time = "2025-08-10T21:26:44.915Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/23/b0/e85a2b48233daef4b648fb657ebbb6f8367696a2d9548a00b4ee0eb67803/kiwisolver-1.4.9-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:1b11d6a633e4ed84fc0ddafd4ebfd8ea49b3f25082c04ad12b8315c11d504dc1", size = 67903, upload_time = "2025-08-10T21:26:45.934Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/44/98/f2425bc0113ad7de24da6bb4dae1343476e95e1d738be7c04d31a5d037fd/kiwisolver-1.4.9-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:61874cdb0a36016354853593cffc38e56fc9ca5aa97d2c05d3dcf6922cd55a11", size = 66402, upload_time = "2025-08-10T21:26:47.101Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/98/d8/594657886df9f34c4177cc353cc28ca7e6e5eb562d37ccc233bff43bbe2a/kiwisolver-1.4.9-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:60c439763a969a6af93b4881db0eed8fadf93ee98e18cbc35bc8da868d0c4f0c", size = 1582135, upload_time = "2025-08-10T21:26:48.665Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5c/c6/38a115b7170f8b306fc929e166340c24958347308ea3012c2b44e7e295db/kiwisolver-1.4.9-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92a2f997387a1b79a75e7803aa7ded2cfbe2823852ccf1ba3bcf613b62ae3197", size = 1389409, upload_time = "2025-08-10T21:26:50.335Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/bf/3b/e04883dace81f24a568bcee6eb3001da4ba05114afa622ec9b6fafdc1f5e/kiwisolver-1.4.9-cp313-cp313t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a31d512c812daea6d8b3be3b2bfcbeb091dbb09177706569bcfc6240dcf8b41c", size = 1401763, upload_time = "2025-08-10T21:26:51.867Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/9f/80/20ace48e33408947af49d7d15c341eaee69e4e0304aab4b7660e234d6288/kiwisolver-1.4.9-cp313-cp313t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:52a15b0f35dad39862d376df10c5230155243a2c1a436e39eb55623ccbd68185", size = 1453643, upload_time = "2025-08-10T21:26:53.592Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/64/31/6ce4380a4cd1f515bdda976a1e90e547ccd47b67a1546d63884463c92ca9/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a30fd6fdef1430fd9e1ba7b3398b5ee4e2887783917a687d86ba69985fb08748", size = 2330818, upload_time = "2025-08-10T21:26:55.051Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fa/e9/3f3fcba3bcc7432c795b82646306e822f3fd74df0ee81f0fa067a1f95668/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:cc9617b46837c6468197b5945e196ee9ca43057bb7d9d1ae688101e4e1dddf64", size = 2419963, upload_time = "2025-08-10T21:26:56.421Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/99/43/7320c50e4133575c66e9f7dadead35ab22d7c012a3b09bb35647792b2a6d/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:0ab74e19f6a2b027ea4f845a78827969af45ce790e6cb3e1ebab71bdf9f215ff", size = 2594639, upload_time = "2025-08-10T21:26:57.882Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/65/d6/17ae4a270d4a987ef8a385b906d2bdfc9fce502d6dc0d3aea865b47f548c/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dba5ee5d3981160c28d5490f0d1b7ed730c22470ff7f6cc26cfcfaacb9896a07", size = 2391741, upload_time = "2025-08-10T21:26:59.237Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2a/8f/8f6f491d595a9e5912971f3f863d81baddccc8a4d0c3749d6a0dd9ffc9df/kiwisolver-1.4.9-cp313-cp313t-win_arm64.whl", hash = "sha256:0749fd8f4218ad2e851e11cc4dc05c7cbc0cbc4267bdfdb31782e65aace4ee9c", size = 68646, upload_time = "2025-08-10T21:27:00.52Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6b/32/6cc0fbc9c54d06c2969faa9c1d29f5751a2e51809dd55c69055e62d9b426/kiwisolver-1.4.9-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:9928fe1eb816d11ae170885a74d074f57af3a0d65777ca47e9aeb854a1fba386", size = 123806, upload_time = "2025-08-10T21:27:01.537Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b2/dd/2bfb1d4a4823d92e8cbb420fe024b8d2167f72079b3bb941207c42570bdf/kiwisolver-1.4.9-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:d0005b053977e7b43388ddec89fa567f43d4f6d5c2c0affe57de5ebf290dc552", size = 66605, upload_time = "2025-08-10T21:27:03.335Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f7/69/00aafdb4e4509c2ca6064646cba9cd4b37933898f426756adb2cb92ebbed/kiwisolver-1.4.9-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:2635d352d67458b66fd0667c14cb1d4145e9560d503219034a18a87e971ce4f3", size = 64925, upload_time = "2025-08-10T21:27:04.339Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/43/dc/51acc6791aa14e5cb6d8a2e28cefb0dc2886d8862795449d021334c0df20/kiwisolver-1.4.9-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:767c23ad1c58c9e827b649a9ab7809fd5fd9db266a9cf02b0e926ddc2c680d58", size = 1472414, upload_time = "2025-08-10T21:27:05.437Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3d/bb/93fa64a81db304ac8a246f834d5094fae4b13baf53c839d6bb6e81177129/kiwisolver-1.4.9-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:72d0eb9fba308b8311685c2268cf7d0a0639a6cd027d8128659f72bdd8a024b4", size = 1281272, upload_time = "2025-08-10T21:27:07.063Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/70/e6/6df102916960fb8d05069d4bd92d6d9a8202d5a3e2444494e7cd50f65b7a/kiwisolver-1.4.9-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f68e4f3eeca8fb22cc3d731f9715a13b652795ef657a13df1ad0c7dc0e9731df", size = 1298578, upload_time = "2025-08-10T21:27:08.452Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/7c/47/e142aaa612f5343736b087864dbaebc53ea8831453fb47e7521fa8658f30/kiwisolver-1.4.9-cp314-cp314-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d84cd4061ae292d8ac367b2c3fa3aad11cb8625a95d135fe93f286f914f3f5a6", size = 1345607, upload_time = "2025-08-10T21:27:10.125Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/54/89/d641a746194a0f4d1a3670fb900d0dbaa786fb98341056814bc3f058fa52/kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a60ea74330b91bd22a29638940d115df9dc00af5035a9a2a6ad9399ffb4ceca5", size = 2230150, upload_time = "2025-08-10T21:27:11.484Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/aa/6b/5ee1207198febdf16ac11f78c5ae40861b809cbe0e6d2a8d5b0b3044b199/kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:ce6a3a4e106cf35c2d9c4fa17c05ce0b180db622736845d4315519397a77beaf", size = 2325979, upload_time = "2025-08-10T21:27:12.917Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fc/ff/b269eefd90f4ae14dcc74973d5a0f6d28d3b9bb1afd8c0340513afe6b39a/kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:77937e5e2a38a7b48eef0585114fe7930346993a88060d0bf886086d2aa49ef5", size = 2491456, upload_time = "2025-08-10T21:27:14.353Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fc/d4/10303190bd4d30de547534601e259a4fbf014eed94aae3e5521129215086/kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:24c175051354f4a28c5d6a31c93906dc653e2bf234e8a4bbfb964892078898ce", size = 2294621, upload_time = "2025-08-10T21:27:15.808Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/28/e0/a9a90416fce5c0be25742729c2ea52105d62eda6c4be4d803c2a7be1fa50/kiwisolver-1.4.9-cp314-cp314-win_amd64.whl", hash = "sha256:0763515d4df10edf6d06a3c19734e2566368980d21ebec439f33f9eb936c07b7", size = 75417, upload_time = "2025-08-10T21:27:17.436Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/1f/10/6949958215b7a9a264299a7db195564e87900f709db9245e4ebdd3c70779/kiwisolver-1.4.9-cp314-cp314-win_arm64.whl", hash = "sha256:0e4e2bf29574a6a7b7f6cb5fa69293b9f96c928949ac4a53ba3f525dffb87f9c", size = 66582, upload_time = "2025-08-10T21:27:18.436Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ec/79/60e53067903d3bc5469b369fe0dfc6b3482e2133e85dae9daa9527535991/kiwisolver-1.4.9-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:d976bbb382b202f71c67f77b0ac11244021cfa3f7dfd9e562eefcea2df711548", size = 126514, upload_time = "2025-08-10T21:27:19.465Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/25/d1/4843d3e8d46b072c12a38c97c57fab4608d36e13fe47d47ee96b4d61ba6f/kiwisolver-1.4.9-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2489e4e5d7ef9a1c300a5e0196e43d9c739f066ef23270607d45aba368b91f2d", size = 67905, upload_time = "2025-08-10T21:27:20.51Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8c/ae/29ffcbd239aea8b93108de1278271ae764dfc0d803a5693914975f200596/kiwisolver-1.4.9-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:e2ea9f7ab7fbf18fffb1b5434ce7c69a07582f7acc7717720f1d69f3e806f90c", size = 66399, upload_time = "2025-08-10T21:27:21.496Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a1/ae/d7ba902aa604152c2ceba5d352d7b62106bedbccc8e95c3934d94472bfa3/kiwisolver-1.4.9-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b34e51affded8faee0dfdb705416153819d8ea9250bbbf7ea1b249bdeb5f1122", size = 1582197, upload_time = "2025-08-10T21:27:22.604Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f2/41/27c70d427eddb8bc7e4f16420a20fefc6f480312122a59a959fdfe0445ad/kiwisolver-1.4.9-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d8aacd3d4b33b772542b2e01beb50187536967b514b00003bdda7589722d2a64", size = 1390125, upload_time = "2025-08-10T21:27:24.036Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/41/42/b3799a12bafc76d962ad69083f8b43b12bf4fe78b097b12e105d75c9b8f1/kiwisolver-1.4.9-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7cf974dd4e35fa315563ac99d6287a1024e4dc2077b8a7d7cd3d2fb65d283134", size = 1402612, upload_time = "2025-08-10T21:27:25.773Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d2/b5/a210ea073ea1cfaca1bb5c55a62307d8252f531beb364e18aa1e0888b5a0/kiwisolver-1.4.9-cp314-cp314t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:85bd218b5ecfbee8c8a82e121802dcb519a86044c9c3b2e4aef02fa05c6da370", size = 1453990, upload_time = "2025-08-10T21:27:27.089Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5f/ce/a829eb8c033e977d7ea03ed32fb3c1781b4fa0433fbadfff29e39c676f32/kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:0856e241c2d3df4efef7c04a1e46b1936b6120c9bcf36dd216e3acd84bc4fb21", size = 2331601, upload_time = "2025-08-10T21:27:29.343Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e0/4b/b5e97eb142eb9cd0072dacfcdcd31b1c66dc7352b0f7c7255d339c0edf00/kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:9af39d6551f97d31a4deebeac6f45b156f9755ddc59c07b402c148f5dbb6482a", size = 2422041, upload_time = "2025-08-10T21:27:30.754Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/40/be/8eb4cd53e1b85ba4edc3a9321666f12b83113a178845593307a3e7891f44/kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:bb4ae2b57fc1d8cbd1cf7b1d9913803681ffa903e7488012be5b76dedf49297f", size = 2594897, upload_time = "2025-08-10T21:27:32.803Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/99/dd/841e9a66c4715477ea0abc78da039832fbb09dac5c35c58dc4c41a407b8a/kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:aedff62918805fb62d43a4aa2ecd4482c380dc76cd31bd7c8878588a61bd0369", size = 2391835, upload_time = "2025-08-10T21:27:34.23Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0c/28/4b2e5c47a0da96896fdfdb006340ade064afa1e63675d01ea5ac222b6d52/kiwisolver-1.4.9-cp314-cp314t-win_amd64.whl", hash = "sha256:1fa333e8b2ce4d9660f2cda9c0e1b6bafcfb2457a9d259faa82289e73ec24891", size = 79988, upload_time = "2025-08-10T21:27:35.587Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/80/be/3578e8afd18c88cdf9cb4cffde75a96d2be38c5a903f1ed0ceec061bd09e/kiwisolver-1.4.9-cp314-cp314t-win_arm64.whl", hash = "sha256:4a48a2ce79d65d363597ef7b567ce3d14d68783d2b2263d98db3d9477805ba32", size = 70260, upload_time = "2025-08-10T21:27:36.606Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a2/63/fde392691690f55b38d5dd7b3710f5353bf7a8e52de93a22968801ab8978/kiwisolver-1.4.9-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:4d1d9e582ad4d63062d34077a9a1e9f3c34088a2ec5135b1f7190c07cf366527", size = 60183, upload_time = "2025-08-10T21:27:37.669Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/27/b1/6aad34edfdb7cced27f371866f211332bba215bfd918ad3322a58f480d8b/kiwisolver-1.4.9-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:deed0c7258ceb4c44ad5ec7d9918f9f14fd05b2be86378d86cf50e63d1e7b771", size = 58675, upload_time = "2025-08-10T21:27:39.031Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/9d/1a/23d855a702bb35a76faed5ae2ba3de57d323f48b1f6b17ee2176c4849463/kiwisolver-1.4.9-pp310-pypy310_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0a590506f303f512dff6b7f75fd2fd18e16943efee932008fe7140e5fa91d80e", size = 80277, upload_time = "2025-08-10T21:27:40.129Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5a/5b/5239e3c2b8fb5afa1e8508f721bb77325f740ab6994d963e61b2b7abcc1e/kiwisolver-1.4.9-pp310-pypy310_pp73-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e09c2279a4d01f099f52d5c4b3d9e208e91edcbd1a175c9662a8b16e000fece9", size = 77994, upload_time = "2025-08-10T21:27:41.181Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f9/1c/5d4d468fb16f8410e596ed0eac02d2c68752aa7dc92997fe9d60a7147665/kiwisolver-1.4.9-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:c9e7cdf45d594ee04d5be1b24dd9d49f3d1590959b2271fb30b5ca2b262c00fb", size = 73744, upload_time = "2025-08-10T21:27:42.254Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a3/0f/36d89194b5a32c054ce93e586d4049b6c2c22887b0eb229c61c68afd3078/kiwisolver-1.4.9-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:720e05574713db64c356e86732c0f3c5252818d05f9df320f0ad8380641acea5", size = 60104, upload_time = "2025-08-10T21:27:43.287Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/52/ba/4ed75f59e4658fd21fe7dde1fee0ac397c678ec3befba3fe6482d987af87/kiwisolver-1.4.9-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:17680d737d5335b552994a2008fab4c851bcd7de33094a82067ef3a576ff02fa", size = 58592, upload_time = "2025-08-10T21:27:44.314Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/33/01/a8ea7c5ea32a9b45ceeaee051a04c8ed4320f5add3c51bfa20879b765b70/kiwisolver-1.4.9-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:85b5352f94e490c028926ea567fc569c52ec79ce131dadb968d3853e809518c2", size = 80281, upload_time = "2025-08-10T21:27:45.369Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/da/e3/dbd2ecdce306f1d07a1aaf324817ee993aab7aee9db47ceac757deabafbe/kiwisolver-1.4.9-pp311-pypy311_pp73-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:464415881e4801295659462c49461a24fb107c140de781d55518c4b80cb6790f", size = 78009, upload_time = "2025-08-10T21:27:46.376Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/da/e9/0d4add7873a73e462aeb45c036a2dead2562b825aa46ba326727b3f31016/kiwisolver-1.4.9-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:fb940820c63a9590d31d88b815e7a3aa5915cad3ce735ab45f0c730b39547de1", size = 73929, upload_time = "2025-08-10T21:27:48.236Z" }, +] + +[[package]] +name = "maibot" +version = "0.11.6" +source = { virtual = "." } +dependencies = [ + { name = "aiohttp" }, + { name = "aiohttp-cors" }, + { name = "colorama" }, + { name = "faiss-cpu" }, + { name = "fastapi" }, + { name = "google-genai" }, + { name = "jieba" }, + { name = "json-repair" }, + { name = "maim-message" }, + { name = "matplotlib" }, + { name = "msgpack" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }, marker = "python_full_version < '3.11'" }, + { name = "numpy", version = "2.3.5", source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "openai" }, + { name = "pandas" }, + { name = "peewee" }, + { name = "pillow" }, + { name = "pyarrow" }, + { name = "pydantic" }, + { name = "pypinyin" }, + { name = "python-dotenv" }, + { name = "python-multipart" }, + { name = "quick-algo" }, + { name = "rich" }, + { name = "ruff" }, + { name = "setuptools" }, + { name = "structlog" }, + { name = "toml" }, + { name = "tomlkit" }, + { name = "urllib3" }, + { name = "uvicorn" }, + { name = "zstandard" }, +] + +[package.metadata] +requires-dist = [ + { name = "aiohttp", specifier = ">=3.12.14" }, + { name = "aiohttp-cors", specifier = ">=0.8.1" }, + { name = "colorama", specifier = ">=0.4.6" }, + { name = "faiss-cpu", specifier = ">=1.11.0" }, + { name = "fastapi", specifier = ">=0.116.0" }, + { name = "google-genai", specifier = ">=1.39.1" }, + { name = "jieba", specifier = ">=0.42.1" }, + { name = "json-repair", specifier = ">=0.47.6" }, + { name = "maim-message" }, + { name = "matplotlib", specifier = ">=3.10.3" }, + { name = "msgpack", specifier = ">=1.1.2" }, + { name = "numpy", specifier = ">=2.2.6" }, + { name = "openai", specifier = ">=1.95.0" }, + { name = "pandas", specifier = ">=2.3.1" }, + { name = "peewee", specifier = ">=3.18.2" }, + { name = "pillow", specifier = ">=11.3.0" }, + { name = "pyarrow", specifier = ">=20.0.0" }, + { name = "pydantic", specifier = ">=2.11.7" }, + { name = "pypinyin", specifier = ">=0.54.0" }, + { name = "python-dotenv", specifier = ">=1.1.1" }, + { name = "python-multipart", specifier = ">=0.0.20" }, + { name = "quick-algo", specifier = ">=0.1.3" }, + { name = "rich", specifier = ">=14.0.0" }, + { name = "ruff", specifier = ">=0.12.2" }, + { name = "setuptools", specifier = ">=80.9.0" }, + { name = "structlog", specifier = ">=25.4.0" }, + { name = "toml", specifier = ">=0.10.2" }, + { name = "tomlkit", specifier = ">=0.13.3" }, + { name = "urllib3", specifier = ">=2.5.0" }, + { name = "uvicorn", specifier = ">=0.35.0" }, + { name = "zstandard", specifier = ">=0.25.0" }, +] + +[[package]] +name = "maim-message" +version = "0.5.7" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +dependencies = [ + { name = "aiohttp" }, + { name = "cryptography" }, + { name = "fastapi" }, + { name = "pydantic" }, + { name = "uvicorn" }, + { name = "websockets" }, +] +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/31/79/5255680b5831cafbf5e99ceb3cecdd229ebc25f6087cb719e136633dd52b/maim_message-0.5.7.tar.gz", hash = "sha256:aaf21aeff890409a53445041c6c77bbfa038672d616556eda8bf981f133f535a", size = 612184, upload_time = "2025-11-03T13:53:03.542Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/84/a2/9b26e4d708b77423b42c65a6db6d538a6dfb4f6e3bd4162efde0bcac7180/maim_message-0.5.7-py3-none-any.whl", hash = "sha256:3ac69ba26d68da128feaa9fff4f7d0da1b691a7bf0a7fd98c97e9fd5faac4717", size = 27808, upload_time = "2025-11-03T13:53:01.024Z" }, +] + +[[package]] +name = "markdown-it-py" +version = "4.0.0" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +dependencies = [ + { name = "mdurl" }, +] +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", hash = "sha256:cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3", size = 73070, upload_time = "2025-08-11T12:57:52.854Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", hash = "sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147", size = 87321, upload_time = "2025-08-11T12:57:51.923Z" }, +] + +[[package]] +name = "matplotlib" +version = "3.10.7" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +dependencies = [ + { name = "contourpy", version = "1.3.2", source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }, marker = "python_full_version < '3.11'" }, + { name = "contourpy", version = "1.3.3", source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "cycler" }, + { name = "fonttools" }, + { name = "kiwisolver" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }, marker = "python_full_version < '3.11'" }, + { name = "numpy", version = "2.3.5", source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "packaging" }, + { name = "pillow" }, + { name = "pyparsing" }, + { name = "python-dateutil" }, +] +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ae/e2/d2d5295be2f44c678ebaf3544ba32d20c1f9ef08c49fe47f496180e1db15/matplotlib-3.10.7.tar.gz", hash = "sha256:a06ba7e2a2ef9131c79c49e63dad355d2d878413a0376c1727c8b9335ff731c7", size = 34804865, upload_time = "2025-10-09T00:28:00.669Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6c/87/3932d5778ab4c025db22710b61f49ccaed3956c5cf46ffb2ffa7492b06d9/matplotlib-3.10.7-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:7ac81eee3b7c266dd92cee1cd658407b16c57eed08c7421fa354ed68234de380", size = 8247141, upload_time = "2025-10-09T00:26:06.023Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/45/a8/bfed45339160102bce21a44e38a358a1134a5f84c26166de03fb4a53208f/matplotlib-3.10.7-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:667ecd5d8d37813a845053d8f5bf110b534c3c9f30e69ebd25d4701385935a6d", size = 8107995, upload_time = "2025-10-09T00:26:08.669Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e2/3c/5692a2d9a5ba848fda3f48d2b607037df96460b941a59ef236404b39776b/matplotlib-3.10.7-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:cc1c51b846aca49a5a8b44fbba6a92d583a35c64590ad9e1e950dc88940a4297", size = 8680503, upload_time = "2025-10-09T00:26:10.607Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ab/a0/86ace53c48b05d0e6e9c127b2ace097434901f3e7b93f050791c8243201a/matplotlib-3.10.7-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4a11c2e9e72e7de09b7b72e62f3df23317c888299c875e2b778abf1eda8c0a42", size = 9514982, upload_time = "2025-10-09T00:26:12.594Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a6/81/ead71e2824da8f72640a64166d10e62300df4ae4db01a0bac56c5b39fa51/matplotlib-3.10.7-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f19410b486fdd139885ace124e57f938c1e6a3210ea13dd29cab58f5d4bc12c7", size = 9566429, upload_time = "2025-10-09T00:26:14.758Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/65/7d/954b3067120456f472cce8fdcacaf4a5fcd522478db0c37bb243c7cb59dd/matplotlib-3.10.7-cp310-cp310-win_amd64.whl", hash = "sha256:b498e9e4022f93de2d5a37615200ca01297ceebbb56fe4c833f46862a490f9e3", size = 8108174, upload_time = "2025-10-09T00:26:17.015Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fc/bc/0fb489005669127ec13f51be0c6adc074d7cf191075dab1da9fe3b7a3cfc/matplotlib-3.10.7-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:53b492410a6cd66c7a471de6c924f6ede976e963c0f3097a3b7abfadddc67d0a", size = 8257507, upload_time = "2025-10-09T00:26:19.073Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e2/6a/d42588ad895279ff6708924645b5d2ed54a7fb2dc045c8a804e955aeace1/matplotlib-3.10.7-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d9749313deb729f08207718d29c86246beb2ea3fdba753595b55901dee5d2fd6", size = 8119565, upload_time = "2025-10-09T00:26:21.023Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/10/b7/4aa196155b4d846bd749cf82aa5a4c300cf55a8b5e0dfa5b722a63c0f8a0/matplotlib-3.10.7-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2222c7ba2cbde7fe63032769f6eb7e83ab3227f47d997a8453377709b7fe3a5a", size = 8692668, upload_time = "2025-10-09T00:26:22.967Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e6/e7/664d2b97016f46683a02d854d730cfcf54ff92c1dafa424beebef50f831d/matplotlib-3.10.7-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e91f61a064c92c307c5a9dc8c05dc9f8a68f0a3be199d9a002a0622e13f874a1", size = 9521051, upload_time = "2025-10-09T00:26:25.041Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a8/a3/37aef1404efa615f49b5758a5e0261c16dd88f389bc1861e722620e4a754/matplotlib-3.10.7-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6f1851eab59ca082c95df5a500106bad73672645625e04538b3ad0f69471ffcc", size = 9576878, upload_time = "2025-10-09T00:26:27.478Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/33/cd/b145f9797126f3f809d177ca378de57c45413c5099c5990de2658760594a/matplotlib-3.10.7-cp311-cp311-win_amd64.whl", hash = "sha256:6516ce375109c60ceec579e699524e9d504cd7578506f01150f7a6bc174a775e", size = 8115142, upload_time = "2025-10-09T00:26:29.774Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2e/39/63bca9d2b78455ed497fcf51a9c71df200a11048f48249038f06447fa947/matplotlib-3.10.7-cp311-cp311-win_arm64.whl", hash = "sha256:b172db79759f5f9bc13ef1c3ef8b9ee7b37b0247f987fbbbdaa15e4f87fd46a9", size = 7992439, upload_time = "2025-10-09T00:26:40.32Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/be/b3/09eb0f7796932826ec20c25b517d568627754f6c6462fca19e12c02f2e12/matplotlib-3.10.7-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7a0edb7209e21840e8361e91ea84ea676658aa93edd5f8762793dec77a4a6748", size = 8272389, upload_time = "2025-10-09T00:26:42.474Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/11/0b/1ae80ddafb8652fd8046cb5c8460ecc8d4afccb89e2c6d6bec61e04e1eaf/matplotlib-3.10.7-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c380371d3c23e0eadf8ebff114445b9f970aff2010198d498d4ab4c3b41eea4f", size = 8128247, upload_time = "2025-10-09T00:26:44.77Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/7d/18/95ae2e242d4a5c98bd6e90e36e128d71cf1c7e39b0874feaed3ef782e789/matplotlib-3.10.7-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d5f256d49fea31f40f166a5e3131235a5d2f4b7f44520b1cf0baf1ce568ccff0", size = 8696996, upload_time = "2025-10-09T00:26:46.792Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/7e/3d/5b559efc800bd05cb2033aa85f7e13af51958136a48327f7c261801ff90a/matplotlib-3.10.7-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:11ae579ac83cdf3fb72573bb89f70e0534de05266728740d478f0f818983c695", size = 9530153, upload_time = "2025-10-09T00:26:49.07Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/88/57/eab4a719fd110312d3c220595d63a3c85ec2a39723f0f4e7fa7e6e3f74ba/matplotlib-3.10.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:4c14b6acd16cddc3569a2d515cfdd81c7a68ac5639b76548cfc1a9e48b20eb65", size = 9593093, upload_time = "2025-10-09T00:26:51.067Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/31/3c/80816f027b3a4a28cd2a0a6ef7f89a2db22310e945cd886ec25bfb399221/matplotlib-3.10.7-cp312-cp312-win_amd64.whl", hash = "sha256:0d8c32b7ea6fb80b1aeff5a2ceb3fb9778e2759e899d9beff75584714afcc5ee", size = 8122771, upload_time = "2025-10-09T00:26:53.296Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/de/77/ef1fc78bfe99999b2675435cc52120887191c566b25017d78beaabef7f2d/matplotlib-3.10.7-cp312-cp312-win_arm64.whl", hash = "sha256:5f3f6d315dcc176ba7ca6e74c7768fb7e4cf566c49cb143f6bc257b62e634ed8", size = 7992812, upload_time = "2025-10-09T00:26:54.882Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/02/9c/207547916a02c78f6bdd83448d9b21afbc42f6379ed887ecf610984f3b4e/matplotlib-3.10.7-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1d9d3713a237970569156cfb4de7533b7c4eacdd61789726f444f96a0d28f57f", size = 8273212, upload_time = "2025-10-09T00:26:56.752Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/bc/d0/b3d3338d467d3fc937f0bb7f256711395cae6f78e22cef0656159950adf0/matplotlib-3.10.7-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:37a1fea41153dd6ee061d21ab69c9cf2cf543160b1b85d89cd3d2e2a7902ca4c", size = 8128713, upload_time = "2025-10-09T00:26:59.001Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/22/ff/6425bf5c20d79aa5b959d1ce9e65f599632345391381c9a104133fe0b171/matplotlib-3.10.7-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b3c4ea4948d93c9c29dc01c0c23eef66f2101bf75158c291b88de6525c55c3d1", size = 8698527, upload_time = "2025-10-09T00:27:00.69Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d0/7f/ccdca06f4c2e6c7989270ed7829b8679466682f4cfc0f8c9986241c023b6/matplotlib-3.10.7-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:22df30ffaa89f6643206cf13877191c63a50e8f800b038bc39bee9d2d4957632", size = 9529690, upload_time = "2025-10-09T00:27:02.664Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b8/95/b80fc2c1f269f21ff3d193ca697358e24408c33ce2b106a7438a45407b63/matplotlib-3.10.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b69676845a0a66f9da30e87f48be36734d6748024b525ec4710be40194282c84", size = 9593732, upload_time = "2025-10-09T00:27:04.653Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e1/b6/23064a96308b9aeceeffa65e96bcde459a2ea4934d311dee20afde7407a0/matplotlib-3.10.7-cp313-cp313-win_amd64.whl", hash = "sha256:744991e0cc863dd669c8dc9136ca4e6e0082be2070b9d793cbd64bec872a6815", size = 8122727, upload_time = "2025-10-09T00:27:06.814Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b3/a6/2faaf48133b82cf3607759027f82b5c702aa99cdfcefb7f93d6ccf26a424/matplotlib-3.10.7-cp313-cp313-win_arm64.whl", hash = "sha256:fba2974df0bf8ce3c995fa84b79cde38326e0f7b5409e7a3a481c1141340bcf7", size = 7992958, upload_time = "2025-10-09T00:27:08.567Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/4a/f0/b018fed0b599bd48d84c08794cb242227fe3341952da102ee9d9682db574/matplotlib-3.10.7-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:932c55d1fa7af4423422cb6a492a31cbcbdbe68fd1a9a3f545aa5e7a143b5355", size = 8316849, upload_time = "2025-10-09T00:27:10.254Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b0/b7/bb4f23856197659f275e11a2a164e36e65e9b48ea3e93c4ec25b4f163198/matplotlib-3.10.7-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5e38c2d581d62ee729a6e144c47a71b3f42fb4187508dbbf4fe71d5612c3433b", size = 8178225, upload_time = "2025-10-09T00:27:12.241Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/62/56/0600609893ff277e6f3ab3c0cef4eafa6e61006c058e84286c467223d4d5/matplotlib-3.10.7-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:786656bb13c237bbcebcd402f65f44dd61ead60ee3deb045af429d889c8dbc67", size = 8711708, upload_time = "2025-10-09T00:27:13.879Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d8/1a/6bfecb0cafe94d6658f2f1af22c43b76cf7a1c2f0dc34ef84cbb6809617e/matplotlib-3.10.7-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:09d7945a70ea43bf9248f4b6582734c2fe726723204a76eca233f24cffc7ef67", size = 9541409, upload_time = "2025-10-09T00:27:15.684Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/08/50/95122a407d7f2e446fd865e2388a232a23f2b81934960ea802f3171518e4/matplotlib-3.10.7-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:d0b181e9fa8daf1d9f2d4c547527b167cb8838fc587deabca7b5c01f97199e84", size = 9594054, upload_time = "2025-10-09T00:27:17.547Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/13/76/75b194a43b81583478a81e78a07da8d9ca6ddf50dd0a2ccabf258059481d/matplotlib-3.10.7-cp313-cp313t-win_amd64.whl", hash = "sha256:31963603041634ce1a96053047b40961f7a29eb8f9a62e80cc2c0427aa1d22a2", size = 8200100, upload_time = "2025-10-09T00:27:20.039Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f5/9e/6aefebdc9f8235c12bdeeda44cc0383d89c1e41da2c400caf3ee2073a3ce/matplotlib-3.10.7-cp313-cp313t-win_arm64.whl", hash = "sha256:aebed7b50aa6ac698c90f60f854b47e48cd2252b30510e7a1feddaf5a3f72cbf", size = 8042131, upload_time = "2025-10-09T00:27:21.608Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0d/4b/e5bc2c321b6a7e3a75638d937d19ea267c34bd5a90e12bee76c4d7c7a0d9/matplotlib-3.10.7-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:d883460c43e8c6b173fef244a2341f7f7c0e9725c7fe68306e8e44ed9c8fb100", size = 8273787, upload_time = "2025-10-09T00:27:23.27Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/86/ad/6efae459c56c2fbc404da154e13e3a6039129f3c942b0152624f1c621f05/matplotlib-3.10.7-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:07124afcf7a6504eafcb8ce94091c5898bbdd351519a1beb5c45f7a38c67e77f", size = 8131348, upload_time = "2025-10-09T00:27:24.926Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a6/5a/a4284d2958dee4116359cc05d7e19c057e64ece1b4ac986ab0f2f4d52d5a/matplotlib-3.10.7-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c17398b709a6cce3d9fdb1595c33e356d91c098cd9486cb2cc21ea2ea418e715", size = 9533949, upload_time = "2025-10-09T00:27:26.704Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/de/ff/f3781b5057fa3786623ad8976fc9f7b0d02b2f28534751fd5a44240de4cf/matplotlib-3.10.7-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7146d64f561498764561e9cd0ed64fcf582e570fc519e6f521e2d0cfd43365e1", size = 9804247, upload_time = "2025-10-09T00:27:28.514Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/47/5a/993a59facb8444efb0e197bf55f545ee449902dcee86a4dfc580c3b61314/matplotlib-3.10.7-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:90ad854c0a435da3104c01e2c6f0028d7e719b690998a2333d7218db80950722", size = 9595497, upload_time = "2025-10-09T00:27:30.418Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0d/a5/77c95aaa9bb32c345cbb49626ad8eb15550cba2e6d4c88081a6c2ac7b08d/matplotlib-3.10.7-cp314-cp314-win_amd64.whl", hash = "sha256:4645fc5d9d20ffa3a39361fcdbcec731382763b623b72627806bf251b6388866", size = 8252732, upload_time = "2025-10-09T00:27:32.332Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/74/04/45d269b4268d222390d7817dae77b159651909669a34ee9fdee336db5883/matplotlib-3.10.7-cp314-cp314-win_arm64.whl", hash = "sha256:9257be2f2a03415f9105c486d304a321168e61ad450f6153d77c69504ad764bb", size = 8124240, upload_time = "2025-10-09T00:27:33.94Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/4b/c7/ca01c607bb827158b439208c153d6f14ddb9fb640768f06f7ca3488ae67b/matplotlib-3.10.7-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1e4bbad66c177a8fdfa53972e5ef8be72a5f27e6a607cec0d8579abd0f3102b1", size = 8316938, upload_time = "2025-10-09T00:27:35.534Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/84/d2/5539e66e9f56d2fdec94bb8436f5e449683b4e199bcc897c44fbe3c99e28/matplotlib-3.10.7-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d8eb7194b084b12feb19142262165832fc6ee879b945491d1c3d4660748020c4", size = 8178245, upload_time = "2025-10-09T00:27:37.334Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/77/b5/e6ca22901fd3e4fe433a82e583436dd872f6c966fca7e63cf806b40356f8/matplotlib-3.10.7-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b4d41379b05528091f00e1728004f9a8d7191260f3862178b88e8fd770206318", size = 9541411, upload_time = "2025-10-09T00:27:39.387Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/9e/99/a4524db57cad8fee54b7237239a8f8360bfcfa3170d37c9e71c090c0f409/matplotlib-3.10.7-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4a74f79fafb2e177f240579bc83f0b60f82cc47d2f1d260f422a0627207008ca", size = 9803664, upload_time = "2025-10-09T00:27:41.492Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e6/a5/85e2edf76ea0ad4288d174926d9454ea85f3ce5390cc4e6fab196cbf250b/matplotlib-3.10.7-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:702590829c30aada1e8cef0568ddbffa77ca747b4d6e36c6d173f66e301f89cc", size = 9594066, upload_time = "2025-10-09T00:27:43.694Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/39/69/9684368a314f6d83fe5c5ad2a4121a3a8e03723d2e5c8ea17b66c1bad0e7/matplotlib-3.10.7-cp314-cp314t-win_amd64.whl", hash = "sha256:f79d5de970fc90cd5591f60053aecfce1fcd736e0303d9f0bf86be649fa68fb8", size = 8342832, upload_time = "2025-10-09T00:27:45.543Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/04/5f/e22e08da14bc1a0894184640d47819d2338b792732e20d292bf86e5ab785/matplotlib-3.10.7-cp314-cp314t-win_arm64.whl", hash = "sha256:cb783436e47fcf82064baca52ce748af71725d0352e1d31564cbe9c95df92b9c", size = 8172585, upload_time = "2025-10-09T00:27:47.185Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/1e/6c/a9bcf03e9afb2a873e0a5855f79bce476d1023f26f8212969f2b7504756c/matplotlib-3.10.7-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:5c09cf8f2793f81368f49f118b6f9f937456362bee282eac575cca7f84cda537", size = 8241204, upload_time = "2025-10-09T00:27:48.806Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5b/fd/0e6f5aa762ed689d9fa8750b08f1932628ffa7ed30e76423c399d19407d2/matplotlib-3.10.7-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:de66744b2bb88d5cd27e80dfc2ec9f0517d0a46d204ff98fe9e5f2864eb67657", size = 8104607, upload_time = "2025-10-09T00:27:50.876Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b9/a9/21c9439d698fac5f0de8fc68b2405b738ed1f00e1279c76f2d9aa5521ead/matplotlib-3.10.7-pp310-pypy310_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:53cc80662dd197ece414dd5b66e07370201515a3eaf52e7c518c68c16814773b", size = 8682257, upload_time = "2025-10-09T00:27:52.597Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/58/8f/76d5dc21ac64a49e5498d7f0472c0781dae442dd266a67458baec38288ec/matplotlib-3.10.7-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:15112bcbaef211bd663fa935ec33313b948e214454d949b723998a43357b17b0", size = 8252283, upload_time = "2025-10-09T00:27:54.739Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/27/0d/9c5d4c2317feb31d819e38c9f947c942f42ebd4eb935fc6fd3518a11eaa7/matplotlib-3.10.7-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:d2a959c640cdeecdd2ec3136e8ea0441da59bcaf58d67e9c590740addba2cb68", size = 8116733, upload_time = "2025-10-09T00:27:56.406Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/9a/cc/3fe688ff1355010937713164caacf9ed443675ac48a997bab6ed23b3f7c0/matplotlib-3.10.7-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3886e47f64611046bc1db523a09dd0a0a6bed6081e6f90e13806dd1d1d1b5e91", size = 8693919, upload_time = "2025-10-09T00:27:58.41Z" }, +] + +[[package]] +name = "mdurl" +version = "0.1.2" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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 = "msgpack" +version = "1.1.2" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/4d/f2/bfb55a6236ed8725a96b0aa3acbd0ec17588e6a2c3b62a93eb513ed8783f/msgpack-1.1.2.tar.gz", hash = "sha256:3b60763c1373dd60f398488069bcdc703cd08a711477b5d480eecc9f9626f47e", size = 173581, upload_time = "2025-10-08T09:15:56.596Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f5/a2/3b68a9e769db68668b25c6108444a35f9bd163bb848c0650d516761a59c0/msgpack-1.1.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0051fffef5a37ca2cd16978ae4f0aef92f164df86823871b5162812bebecd8e2", size = 81318, upload_time = "2025-10-08T09:14:38.722Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5b/e1/2b720cc341325c00be44e1ed59e7cfeae2678329fbf5aa68f5bda57fe728/msgpack-1.1.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a605409040f2da88676e9c9e5853b3449ba8011973616189ea5ee55ddbc5bc87", size = 83786, upload_time = "2025-10-08T09:14:40.082Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/71/e5/c2241de64bfceac456b140737812a2ab310b10538a7b34a1d393b748e095/msgpack-1.1.2-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b696e83c9f1532b4af884045ba7f3aa741a63b2bc22617293a2c6a7c645f251", size = 398240, upload_time = "2025-10-08T09:14:41.151Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b7/09/2a06956383c0fdebaef5aa9246e2356776f12ea6f2a44bd1368abf0e46c4/msgpack-1.1.2-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:365c0bbe981a27d8932da71af63ef86acc59ed5c01ad929e09a0b88c6294e28a", size = 406070, upload_time = "2025-10-08T09:14:42.821Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0e/74/2957703f0e1ef20637d6aead4fbb314330c26f39aa046b348c7edcf6ca6b/msgpack-1.1.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:41d1a5d875680166d3ac5c38573896453bbbea7092936d2e107214daf43b1d4f", size = 393403, upload_time = "2025-10-08T09:14:44.38Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a5/09/3bfc12aa90f77b37322fc33e7a8a7c29ba7c8edeadfa27664451801b9860/msgpack-1.1.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:354e81bcdebaab427c3df4281187edc765d5d76bfb3a7c125af9da7a27e8458f", size = 398947, upload_time = "2025-10-08T09:14:45.56Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/4b/4f/05fcebd3b4977cb3d840f7ef6b77c51f8582086de5e642f3fefee35c86fc/msgpack-1.1.2-cp310-cp310-win32.whl", hash = "sha256:e64c8d2f5e5d5fda7b842f55dec6133260ea8f53c4257d64494c534f306bf7a9", size = 64769, upload_time = "2025-10-08T09:14:47.334Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d0/3e/b4547e3a34210956382eed1c85935fff7e0f9b98be3106b3745d7dec9c5e/msgpack-1.1.2-cp310-cp310-win_amd64.whl", hash = "sha256:db6192777d943bdaaafb6ba66d44bf65aa0e9c5616fa1d2da9bb08828c6b39aa", size = 71293, upload_time = "2025-10-08T09:14:48.665Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2c/97/560d11202bcd537abca693fd85d81cebe2107ba17301de42b01ac1677b69/msgpack-1.1.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2e86a607e558d22985d856948c12a3fa7b42efad264dca8a3ebbcfa2735d786c", size = 82271, upload_time = "2025-10-08T09:14:49.967Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/83/04/28a41024ccbd67467380b6fb440ae916c1e4f25e2cd4c63abe6835ac566e/msgpack-1.1.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:283ae72fc89da59aa004ba147e8fc2f766647b1251500182fac0350d8af299c0", size = 84914, upload_time = "2025-10-08T09:14:50.958Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/71/46/b817349db6886d79e57a966346cf0902a426375aadc1e8e7a86a75e22f19/msgpack-1.1.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:61c8aa3bd513d87c72ed0b37b53dd5c5a0f58f2ff9f26e1555d3bd7948fb7296", size = 416962, upload_time = "2025-10-08T09:14:51.997Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/da/e0/6cc2e852837cd6086fe7d8406af4294e66827a60a4cf60b86575a4a65ca8/msgpack-1.1.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:454e29e186285d2ebe65be34629fa0e8605202c60fbc7c4c650ccd41870896ef", size = 426183, upload_time = "2025-10-08T09:14:53.477Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/25/98/6a19f030b3d2ea906696cedd1eb251708e50a5891d0978b012cb6107234c/msgpack-1.1.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7bc8813f88417599564fafa59fd6f95be417179f76b40325b500b3c98409757c", size = 411454, upload_time = "2025-10-08T09:14:54.648Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b7/cd/9098fcb6adb32187a70b7ecaabf6339da50553351558f37600e53a4a2a23/msgpack-1.1.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bafca952dc13907bdfdedfc6a5f579bf4f292bdd506fadb38389afa3ac5b208e", size = 422341, upload_time = "2025-10-08T09:14:56.328Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e6/ae/270cecbcf36c1dc85ec086b33a51a4d7d08fc4f404bdbc15b582255d05ff/msgpack-1.1.2-cp311-cp311-win32.whl", hash = "sha256:602b6740e95ffc55bfb078172d279de3773d7b7db1f703b2f1323566b878b90e", size = 64747, upload_time = "2025-10-08T09:14:57.882Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2a/79/309d0e637f6f37e83c711f547308b91af02b72d2326ddd860b966080ef29/msgpack-1.1.2-cp311-cp311-win_amd64.whl", hash = "sha256:d198d275222dc54244bf3327eb8cbe00307d220241d9cec4d306d49a44e85f68", size = 71633, upload_time = "2025-10-08T09:14:59.177Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/73/4d/7c4e2b3d9b1106cd0aa6cb56cc57c6267f59fa8bfab7d91df5adc802c847/msgpack-1.1.2-cp311-cp311-win_arm64.whl", hash = "sha256:86f8136dfa5c116365a8a651a7d7484b65b13339731dd6faebb9a0242151c406", size = 64755, upload_time = "2025-10-08T09:15:00.48Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ad/bd/8b0d01c756203fbab65d265859749860682ccd2a59594609aeec3a144efa/msgpack-1.1.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:70a0dff9d1f8da25179ffcf880e10cf1aad55fdb63cd59c9a49a1b82290062aa", size = 81939, upload_time = "2025-10-08T09:15:01.472Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/34/68/ba4f155f793a74c1483d4bdef136e1023f7bcba557f0db4ef3db3c665cf1/msgpack-1.1.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:446abdd8b94b55c800ac34b102dffd2f6aa0ce643c55dfc017ad89347db3dbdb", size = 85064, upload_time = "2025-10-08T09:15:03.764Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f2/60/a064b0345fc36c4c3d2c743c82d9100c40388d77f0b48b2f04d6041dbec1/msgpack-1.1.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c63eea553c69ab05b6747901b97d620bb2a690633c77f23feb0c6a947a8a7b8f", size = 417131, upload_time = "2025-10-08T09:15:05.136Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/65/92/a5100f7185a800a5d29f8d14041f61475b9de465ffcc0f3b9fba606e4505/msgpack-1.1.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:372839311ccf6bdaf39b00b61288e0557916c3729529b301c52c2d88842add42", size = 427556, upload_time = "2025-10-08T09:15:06.837Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f5/87/ffe21d1bf7d9991354ad93949286f643b2bb6ddbeab66373922b44c3b8cc/msgpack-1.1.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2929af52106ca73fcb28576218476ffbb531a036c2adbcf54a3664de124303e9", size = 404920, upload_time = "2025-10-08T09:15:08.179Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ff/41/8543ed2b8604f7c0d89ce066f42007faac1eaa7d79a81555f206a5cdb889/msgpack-1.1.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:be52a8fc79e45b0364210eef5234a7cf8d330836d0a64dfbb878efa903d84620", size = 415013, upload_time = "2025-10-08T09:15:09.83Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/41/0d/2ddfaa8b7e1cee6c490d46cb0a39742b19e2481600a7a0e96537e9c22f43/msgpack-1.1.2-cp312-cp312-win32.whl", hash = "sha256:1fff3d825d7859ac888b0fbda39a42d59193543920eda9d9bea44d958a878029", size = 65096, upload_time = "2025-10-08T09:15:11.11Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8c/ec/d431eb7941fb55a31dd6ca3404d41fbb52d99172df2e7707754488390910/msgpack-1.1.2-cp312-cp312-win_amd64.whl", hash = "sha256:1de460f0403172cff81169a30b9a92b260cb809c4cb7e2fc79ae8d0510c78b6b", size = 72708, upload_time = "2025-10-08T09:15:12.554Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c5/31/5b1a1f70eb0e87d1678e9624908f86317787b536060641d6798e3cf70ace/msgpack-1.1.2-cp312-cp312-win_arm64.whl", hash = "sha256:be5980f3ee0e6bd44f3a9e9dea01054f175b50c3e6cdb692bc9424c0bbb8bf69", size = 64119, upload_time = "2025-10-08T09:15:13.589Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6b/31/b46518ecc604d7edf3a4f94cb3bf021fc62aa301f0cb849936968164ef23/msgpack-1.1.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4efd7b5979ccb539c221a4c4e16aac1a533efc97f3b759bb5a5ac9f6d10383bf", size = 81212, upload_time = "2025-10-08T09:15:14.552Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/92/dc/c385f38f2c2433333345a82926c6bfa5ecfff3ef787201614317b58dd8be/msgpack-1.1.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:42eefe2c3e2af97ed470eec850facbe1b5ad1d6eacdbadc42ec98e7dcf68b4b7", size = 84315, upload_time = "2025-10-08T09:15:15.543Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d3/68/93180dce57f684a61a88a45ed13047558ded2be46f03acb8dec6d7c513af/msgpack-1.1.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1fdf7d83102bf09e7ce3357de96c59b627395352a4024f6e2458501f158bf999", size = 412721, upload_time = "2025-10-08T09:15:16.567Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5d/ba/459f18c16f2b3fc1a1ca871f72f07d70c07bf768ad0a507a698b8052ac58/msgpack-1.1.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fac4be746328f90caa3cd4bc67e6fe36ca2bf61d5c6eb6d895b6527e3f05071e", size = 424657, upload_time = "2025-10-08T09:15:17.825Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/38/f8/4398c46863b093252fe67368b44edc6c13b17f4e6b0e4929dbf0bdb13f23/msgpack-1.1.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:fffee09044073e69f2bad787071aeec727183e7580443dfeb8556cbf1978d162", size = 402668, upload_time = "2025-10-08T09:15:19.003Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/28/ce/698c1eff75626e4124b4d78e21cca0b4cc90043afb80a507626ea354ab52/msgpack-1.1.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5928604de9b032bc17f5099496417f113c45bc6bc21b5c6920caf34b3c428794", size = 419040, upload_time = "2025-10-08T09:15:20.183Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/67/32/f3cd1667028424fa7001d82e10ee35386eea1408b93d399b09fb0aa7875f/msgpack-1.1.2-cp313-cp313-win32.whl", hash = "sha256:a7787d353595c7c7e145e2331abf8b7ff1e6673a6b974ded96e6d4ec09f00c8c", size = 65037, upload_time = "2025-10-08T09:15:21.416Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/74/07/1ed8277f8653c40ebc65985180b007879f6a836c525b3885dcc6448ae6cb/msgpack-1.1.2-cp313-cp313-win_amd64.whl", hash = "sha256:a465f0dceb8e13a487e54c07d04ae3ba131c7c5b95e2612596eafde1dccf64a9", size = 72631, upload_time = "2025-10-08T09:15:22.431Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e5/db/0314e4e2db56ebcf450f277904ffd84a7988b9e5da8d0d61ab2d057df2b6/msgpack-1.1.2-cp313-cp313-win_arm64.whl", hash = "sha256:e69b39f8c0aa5ec24b57737ebee40be647035158f14ed4b40e6f150077e21a84", size = 64118, upload_time = "2025-10-08T09:15:23.402Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/22/71/201105712d0a2ff07b7873ed3c220292fb2ea5120603c00c4b634bcdafb3/msgpack-1.1.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e23ce8d5f7aa6ea6d2a2b326b4ba46c985dbb204523759984430db7114f8aa00", size = 81127, upload_time = "2025-10-08T09:15:24.408Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/1b/9f/38ff9e57a2eade7bf9dfee5eae17f39fc0e998658050279cbb14d97d36d9/msgpack-1.1.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:6c15b7d74c939ebe620dd8e559384be806204d73b4f9356320632d783d1f7939", size = 84981, upload_time = "2025-10-08T09:15:25.812Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8e/a9/3536e385167b88c2cc8f4424c49e28d49a6fc35206d4a8060f136e71f94c/msgpack-1.1.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:99e2cb7b9031568a2a5c73aa077180f93dd2e95b4f8d3b8e14a73ae94a9e667e", size = 411885, upload_time = "2025-10-08T09:15:27.22Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2f/40/dc34d1a8d5f1e51fc64640b62b191684da52ca469da9cd74e84936ffa4a6/msgpack-1.1.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:180759d89a057eab503cf62eeec0aa61c4ea1200dee709f3a8e9397dbb3b6931", size = 419658, upload_time = "2025-10-08T09:15:28.4Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3b/ef/2b92e286366500a09a67e03496ee8b8ba00562797a52f3c117aa2b29514b/msgpack-1.1.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:04fb995247a6e83830b62f0b07bf36540c213f6eac8e851166d8d86d83cbd014", size = 403290, upload_time = "2025-10-08T09:15:29.764Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/78/90/e0ea7990abea5764e4655b8177aa7c63cdfa89945b6e7641055800f6c16b/msgpack-1.1.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:8e22ab046fa7ede9e36eeb4cfad44d46450f37bb05d5ec482b02868f451c95e2", size = 415234, upload_time = "2025-10-08T09:15:31.022Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/72/4e/9390aed5db983a2310818cd7d3ec0aecad45e1f7007e0cda79c79507bb0d/msgpack-1.1.2-cp314-cp314-win32.whl", hash = "sha256:80a0ff7d4abf5fecb995fcf235d4064b9a9a8a40a3ab80999e6ac1e30b702717", size = 66391, upload_time = "2025-10-08T09:15:32.265Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6e/f1/abd09c2ae91228c5f3998dbd7f41353def9eac64253de3c8105efa2082f7/msgpack-1.1.2-cp314-cp314-win_amd64.whl", hash = "sha256:9ade919fac6a3e7260b7f64cea89df6bec59104987cbea34d34a2fa15d74310b", size = 73787, upload_time = "2025-10-08T09:15:33.219Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6a/b0/9d9f667ab48b16ad4115c1935d94023b82b3198064cb84a123e97f7466c1/msgpack-1.1.2-cp314-cp314-win_arm64.whl", hash = "sha256:59415c6076b1e30e563eb732e23b994a61c159cec44deaf584e5cc1dd662f2af", size = 66453, upload_time = "2025-10-08T09:15:34.225Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/16/67/93f80545eb1792b61a217fa7f06d5e5cb9e0055bed867f43e2b8e012e137/msgpack-1.1.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:897c478140877e5307760b0ea66e0932738879e7aa68144d9b78ea4c8302a84a", size = 85264, upload_time = "2025-10-08T09:15:35.61Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/87/1c/33c8a24959cf193966ef11a6f6a2995a65eb066bd681fd085afd519a57ce/msgpack-1.1.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a668204fa43e6d02f89dbe79a30b0d67238d9ec4c5bd8a940fc3a004a47b721b", size = 89076, upload_time = "2025-10-08T09:15:36.619Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fc/6b/62e85ff7193663fbea5c0254ef32f0c77134b4059f8da89b958beb7696f3/msgpack-1.1.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5559d03930d3aa0f3aacb4c42c776af1a2ace2611871c84a75afe436695e6245", size = 435242, upload_time = "2025-10-08T09:15:37.647Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c1/47/5c74ecb4cc277cf09f64e913947871682ffa82b3b93c8dad68083112f412/msgpack-1.1.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:70c5a7a9fea7f036b716191c29047374c10721c389c21e9ffafad04df8c52c90", size = 432509, upload_time = "2025-10-08T09:15:38.794Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/24/a4/e98ccdb56dc4e98c929a3f150de1799831c0a800583cde9fa022fa90602d/msgpack-1.1.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:f2cb069d8b981abc72b41aea1c580ce92d57c673ec61af4c500153a626cb9e20", size = 415957, upload_time = "2025-10-08T09:15:40.238Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/da/28/6951f7fb67bc0a4e184a6b38ab71a92d9ba58080b27a77d3e2fb0be5998f/msgpack-1.1.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d62ce1f483f355f61adb5433ebfd8868c5f078d1a52d042b0a998682b4fa8c27", size = 422910, upload_time = "2025-10-08T09:15:41.505Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f0/03/42106dcded51f0a0b5284d3ce30a671e7bd3f7318d122b2ead66ad289fed/msgpack-1.1.2-cp314-cp314t-win32.whl", hash = "sha256:1d1418482b1ee984625d88aa9585db570180c286d942da463533b238b98b812b", size = 75197, upload_time = "2025-10-08T09:15:42.954Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/15/86/d0071e94987f8db59d4eeb386ddc64d0bb9b10820a8d82bcd3e53eeb2da6/msgpack-1.1.2-cp314-cp314t-win_amd64.whl", hash = "sha256:5a46bf7e831d09470ad92dff02b8b1ac92175ca36b087f904a0519857c6be3ff", size = 85772, upload_time = "2025-10-08T09:15:43.954Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/81/f2/08ace4142eb281c12701fc3b93a10795e4d4dc7f753911d836675050f886/msgpack-1.1.2-cp314-cp314t-win_arm64.whl", hash = "sha256:d99ef64f349d5ec3293688e91486c5fdb925ed03807f64d98d205d2713c60b46", size = 70868, upload_time = "2025-10-08T09:15:44.959Z" }, +] + +[[package]] +name = "multidict" +version = "6.7.0" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +dependencies = [ + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/80/1e/5492c365f222f907de1039b91f922b93fa4f764c713ee858d235495d8f50/multidict-6.7.0.tar.gz", hash = "sha256:c6e99d9a65ca282e578dfea819cfa9c0a62b2499d8677392e09feaf305e9e6f5", size = 101834, upload_time = "2025-10-06T14:52:30.657Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a9/63/7bdd4adc330abcca54c85728db2327130e49e52e8c3ce685cec44e0f2e9f/multidict-6.7.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:9f474ad5acda359c8758c8accc22032c6abe6dc87a8be2440d097785e27a9349", size = 77153, upload_time = "2025-10-06T14:48:26.409Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3f/bb/b6c35ff175ed1a3142222b78455ee31be71a8396ed3ab5280fbe3ebe4e85/multidict-6.7.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:4b7a9db5a870f780220e931d0002bbfd88fb53aceb6293251e2c839415c1b20e", size = 44993, upload_time = "2025-10-06T14:48:28.4Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e0/1f/064c77877c5fa6df6d346e68075c0f6998547afe952d6471b4c5f6a7345d/multidict-6.7.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:03ca744319864e92721195fa28c7a3b2bc7b686246b35e4078c1e4d0eb5466d3", size = 44607, upload_time = "2025-10-06T14:48:29.581Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/04/7a/bf6aa92065dd47f287690000b3d7d332edfccb2277634cadf6a810463c6a/multidict-6.7.0-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:f0e77e3c0008bc9316e662624535b88d360c3a5d3f81e15cf12c139a75250046", size = 241847, upload_time = "2025-10-06T14:48:32.107Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/94/39/297a8de920f76eda343e4ce05f3b489f0ab3f9504f2576dfb37b7c08ca08/multidict-6.7.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:08325c9e5367aa379a3496aa9a022fe8837ff22e00b94db256d3a1378c76ab32", size = 242616, upload_time = "2025-10-06T14:48:34.054Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/39/3a/d0eee2898cfd9d654aea6cb8c4addc2f9756e9a7e09391cfe55541f917f7/multidict-6.7.0-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e2862408c99f84aa571ab462d25236ef9cb12a602ea959ba9c9009a54902fc73", size = 222333, upload_time = "2025-10-06T14:48:35.9Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/05/48/3b328851193c7a4240815b71eea165b49248867bbb6153a0aee227a0bb47/multidict-6.7.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4d72a9a2d885f5c208b0cb91ff2ed43636bb7e345ec839ff64708e04f69a13cc", size = 253239, upload_time = "2025-10-06T14:48:37.302Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b1/ca/0706a98c8d126a89245413225ca4a3fefc8435014de309cf8b30acb68841/multidict-6.7.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:478cc36476687bac1514d651cbbaa94b86b0732fb6855c60c673794c7dd2da62", size = 251618, upload_time = "2025-10-06T14:48:38.963Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5e/4f/9c7992f245554d8b173f6f0a048ad24b3e645d883f096857ec2c0822b8bd/multidict-6.7.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6843b28b0364dc605f21481c90fadb5f60d9123b442eb8a726bb74feef588a84", size = 241655, upload_time = "2025-10-06T14:48:40.312Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/31/79/26a85991ae67efd1c0b1fc2e0c275b8a6aceeb155a68861f63f87a798f16/multidict-6.7.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:23bfeee5316266e5ee2d625df2d2c602b829435fc3a235c2ba2131495706e4a0", size = 239245, upload_time = "2025-10-06T14:48:41.848Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/14/1e/75fa96394478930b79d0302eaf9a6c69f34005a1a5251ac8b9c336486ec9/multidict-6.7.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:680878b9f3d45c31e1f730eef731f9b0bc1da456155688c6745ee84eb818e90e", size = 233523, upload_time = "2025-10-06T14:48:43.749Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b2/5e/085544cb9f9c4ad2b5d97467c15f856df8d9bac410cffd5c43991a5d878b/multidict-6.7.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:eb866162ef2f45063acc7a53a88ef6fe8bf121d45c30ea3c9cd87ce7e191a8d4", size = 243129, upload_time = "2025-10-06T14:48:45.225Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b9/c3/e9d9e2f20c9474e7a8fcef28f863c5cbd29bb5adce6b70cebe8bdad0039d/multidict-6.7.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:df0e3bf7993bdbeca5ac25aa859cf40d39019e015c9c91809ba7093967f7a648", size = 248999, upload_time = "2025-10-06T14:48:46.703Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b5/3f/df171b6efa3239ae33b97b887e42671cd1d94d460614bfb2c30ffdab3b95/multidict-6.7.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:661709cdcd919a2ece2234f9bae7174e5220c80b034585d7d8a755632d3e2111", size = 243711, upload_time = "2025-10-06T14:48:48.146Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3c/2f/9b5564888c4e14b9af64c54acf149263721a283aaf4aa0ae89b091d5d8c1/multidict-6.7.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:096f52730c3fb8ed419db2d44391932b63891b2c5ed14850a7e215c0ba9ade36", size = 237504, upload_time = "2025-10-06T14:48:49.447Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6c/3a/0bd6ca0f7d96d790542d591c8c3354c1e1b6bfd2024d4d92dc3d87485ec7/multidict-6.7.0-cp310-cp310-win32.whl", hash = "sha256:afa8a2978ec65d2336305550535c9c4ff50ee527914328c8677b3973ade52b85", size = 41422, upload_time = "2025-10-06T14:48:50.789Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/00/35/f6a637ea2c75f0d3b7c7d41b1189189acff0d9deeb8b8f35536bb30f5e33/multidict-6.7.0-cp310-cp310-win_amd64.whl", hash = "sha256:b15b3afff74f707b9275d5ba6a91ae8f6429c3ffb29bbfd216b0b375a56f13d7", size = 46050, upload_time = "2025-10-06T14:48:51.938Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e7/b8/f7bf8329b39893d02d9d95cf610c75885d12fc0f402b1c894e1c8e01c916/multidict-6.7.0-cp310-cp310-win_arm64.whl", hash = "sha256:4b73189894398d59131a66ff157837b1fafea9974be486d036bb3d32331fdbf0", size = 43153, upload_time = "2025-10-06T14:48:53.146Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/34/9e/5c727587644d67b2ed479041e4b1c58e30afc011e3d45d25bbe35781217c/multidict-6.7.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:4d409aa42a94c0b3fa617708ef5276dfe81012ba6753a0370fcc9d0195d0a1fc", size = 76604, upload_time = "2025-10-06T14:48:54.277Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/17/e4/67b5c27bd17c085a5ea8f1ec05b8a3e5cba0ca734bfcad5560fb129e70ca/multidict-6.7.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:14c9e076eede3b54c636f8ce1c9c252b5f057c62131211f0ceeec273810c9721", size = 44715, upload_time = "2025-10-06T14:48:55.445Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/4d/e1/866a5d77be6ea435711bef2a4291eed11032679b6b28b56b4776ab06ba3e/multidict-6.7.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4c09703000a9d0fa3c3404b27041e574cc7f4df4c6563873246d0e11812a94b6", size = 44332, upload_time = "2025-10-06T14:48:56.706Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/31/61/0c2d50241ada71ff61a79518db85ada85fdabfcf395d5968dae1cbda04e5/multidict-6.7.0-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:a265acbb7bb33a3a2d626afbe756371dce0279e7b17f4f4eda406459c2b5ff1c", size = 245212, upload_time = "2025-10-06T14:48:58.042Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ac/e0/919666a4e4b57fff1b57f279be1c9316e6cdc5de8a8b525d76f6598fefc7/multidict-6.7.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:51cb455de290ae462593e5b1cb1118c5c22ea7f0d3620d9940bf695cea5a4bd7", size = 246671, upload_time = "2025-10-06T14:49:00.004Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a1/cc/d027d9c5a520f3321b65adea289b965e7bcbd2c34402663f482648c716ce/multidict-6.7.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:db99677b4457c7a5c5a949353e125ba72d62b35f74e26da141530fbb012218a7", size = 225491, upload_time = "2025-10-06T14:49:01.393Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/75/c4/bbd633980ce6155a28ff04e6a6492dd3335858394d7bb752d8b108708558/multidict-6.7.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f470f68adc395e0183b92a2f4689264d1ea4b40504a24d9882c27375e6662bb9", size = 257322, upload_time = "2025-10-06T14:49:02.745Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/4c/6d/d622322d344f1f053eae47e033b0b3f965af01212de21b10bcf91be991fb/multidict-6.7.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0db4956f82723cc1c270de9c6e799b4c341d327762ec78ef82bb962f79cc07d8", size = 254694, upload_time = "2025-10-06T14:49:04.15Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a8/9f/78f8761c2705d4c6d7516faed63c0ebdac569f6db1bef95e0d5218fdc146/multidict-6.7.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3e56d780c238f9e1ae66a22d2adf8d16f485381878250db8d496623cd38b22bd", size = 246715, upload_time = "2025-10-06T14:49:05.967Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/78/59/950818e04f91b9c2b95aab3d923d9eabd01689d0dcd889563988e9ea0fd8/multidict-6.7.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:9d14baca2ee12c1a64740d4531356ba50b82543017f3ad6de0deb943c5979abb", size = 243189, upload_time = "2025-10-06T14:49:07.37Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/7a/3d/77c79e1934cad2ee74991840f8a0110966d9599b3af95964c0cd79bb905b/multidict-6.7.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:295a92a76188917c7f99cda95858c822f9e4aae5824246bba9b6b44004ddd0a6", size = 237845, upload_time = "2025-10-06T14:49:08.759Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/63/1b/834ce32a0a97a3b70f86437f685f880136677ac00d8bce0027e9fd9c2db7/multidict-6.7.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:39f1719f57adbb767ef592a50ae5ebb794220d1188f9ca93de471336401c34d2", size = 246374, upload_time = "2025-10-06T14:49:10.574Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/23/ef/43d1c3ba205b5dec93dc97f3fba179dfa47910fc73aaaea4f7ceb41cec2a/multidict-6.7.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:0a13fb8e748dfc94749f622de065dd5c1def7e0d2216dba72b1d8069a389c6ff", size = 253345, upload_time = "2025-10-06T14:49:12.331Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6b/03/eaf95bcc2d19ead522001f6a650ef32811aa9e3624ff0ad37c445c7a588c/multidict-6.7.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:e3aa16de190d29a0ea1b48253c57d99a68492c8dd8948638073ab9e74dc9410b", size = 246940, upload_time = "2025-10-06T14:49:13.821Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e8/df/ec8a5fd66ea6cd6f525b1fcbb23511b033c3e9bc42b81384834ffa484a62/multidict-6.7.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a048ce45dcdaaf1defb76b2e684f997fb5abf74437b6cb7b22ddad934a964e34", size = 242229, upload_time = "2025-10-06T14:49:15.603Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8a/a2/59b405d59fd39ec86d1142630e9049243015a5f5291ba49cadf3c090c541/multidict-6.7.0-cp311-cp311-win32.whl", hash = "sha256:a90af66facec4cebe4181b9e62a68be65e45ac9b52b67de9eec118701856e7ff", size = 41308, upload_time = "2025-10-06T14:49:16.871Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/32/0f/13228f26f8b882c34da36efa776c3b7348455ec383bab4a66390e42963ae/multidict-6.7.0-cp311-cp311-win_amd64.whl", hash = "sha256:95b5ffa4349df2887518bb839409bcf22caa72d82beec453216802f475b23c81", size = 46037, upload_time = "2025-10-06T14:49:18.457Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/84/1f/68588e31b000535a3207fd3c909ebeec4fb36b52c442107499c18a896a2a/multidict-6.7.0-cp311-cp311-win_arm64.whl", hash = "sha256:329aa225b085b6f004a4955271a7ba9f1087e39dcb7e65f6284a988264a63912", size = 43023, upload_time = "2025-10-06T14:49:19.648Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c2/9e/9f61ac18d9c8b475889f32ccfa91c9f59363480613fc807b6e3023d6f60b/multidict-6.7.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:8a3862568a36d26e650a19bb5cbbba14b71789032aebc0423f8cc5f150730184", size = 76877, upload_time = "2025-10-06T14:49:20.884Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/38/6f/614f09a04e6184f8824268fce4bc925e9849edfa654ddd59f0b64508c595/multidict-6.7.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:960c60b5849b9b4f9dcc9bea6e3626143c252c74113df2c1540aebce70209b45", size = 45467, upload_time = "2025-10-06T14:49:22.054Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b3/93/c4f67a436dd026f2e780c433277fff72be79152894d9fc36f44569cab1a6/multidict-6.7.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2049be98fb57a31b4ccf870bf377af2504d4ae35646a19037ec271e4c07998aa", size = 43834, upload_time = "2025-10-06T14:49:23.566Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/7f/f5/013798161ca665e4a422afbc5e2d9e4070142a9ff8905e482139cd09e4d0/multidict-6.7.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:0934f3843a1860dd465d38895c17fce1f1cb37295149ab05cd1b9a03afacb2a7", size = 250545, upload_time = "2025-10-06T14:49:24.882Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/71/2f/91dbac13e0ba94669ea5119ba267c9a832f0cb65419aca75549fcf09a3dc/multidict-6.7.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b3e34f3a1b8131ba06f1a73adab24f30934d148afcd5f5de9a73565a4404384e", size = 258305, upload_time = "2025-10-06T14:49:26.778Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ef/b0/754038b26f6e04488b48ac621f779c341338d78503fb45403755af2df477/multidict-6.7.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:efbb54e98446892590dc2458c19c10344ee9a883a79b5cec4bc34d6656e8d546", size = 242363, upload_time = "2025-10-06T14:49:28.562Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/87/15/9da40b9336a7c9fa606c4cf2ed80a649dffeb42b905d4f63a1d7eb17d746/multidict-6.7.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a35c5fc61d4f51eb045061e7967cfe3123d622cd500e8868e7c0c592a09fedc4", size = 268375, upload_time = "2025-10-06T14:49:29.96Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/82/72/c53fcade0cc94dfaad583105fd92b3a783af2091eddcb41a6d5a52474000/multidict-6.7.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:29fe6740ebccba4175af1b9b87bf553e9c15cd5868ee967e010efcf94e4fd0f1", size = 269346, upload_time = "2025-10-06T14:49:31.404Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0d/e2/9baffdae21a76f77ef8447f1a05a96ec4bc0a24dae08767abc0a2fe680b8/multidict-6.7.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:123e2a72e20537add2f33a79e605f6191fba2afda4cbb876e35c1a7074298a7d", size = 256107, upload_time = "2025-10-06T14:49:32.974Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3c/06/3f06f611087dc60d65ef775f1fb5aca7c6d61c6db4990e7cda0cef9b1651/multidict-6.7.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:b284e319754366c1aee2267a2036248b24eeb17ecd5dc16022095e747f2f4304", size = 253592, upload_time = "2025-10-06T14:49:34.52Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/20/24/54e804ec7945b6023b340c412ce9c3f81e91b3bf5fa5ce65558740141bee/multidict-6.7.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:803d685de7be4303b5a657b76e2f6d1240e7e0a8aa2968ad5811fa2285553a12", size = 251024, upload_time = "2025-10-06T14:49:35.956Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/14/48/011cba467ea0b17ceb938315d219391d3e421dfd35928e5dbdc3f4ae76ef/multidict-6.7.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:c04a328260dfd5db8c39538f999f02779012268f54614902d0afc775d44e0a62", size = 251484, upload_time = "2025-10-06T14:49:37.631Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0d/2f/919258b43bb35b99fa127435cfb2d91798eb3a943396631ef43e3720dcf4/multidict-6.7.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:8a19cdb57cd3df4cd865849d93ee14920fb97224300c88501f16ecfa2604b4e0", size = 263579, upload_time = "2025-10-06T14:49:39.502Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/31/22/a0e884d86b5242b5a74cf08e876bdf299e413016b66e55511f7a804a366e/multidict-6.7.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:9b2fd74c52accced7e75de26023b7dccee62511a600e62311b918ec5c168fc2a", size = 259654, upload_time = "2025-10-06T14:49:41.32Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b2/e5/17e10e1b5c5f5a40f2fcbb45953c9b215f8a4098003915e46a93f5fcaa8f/multidict-6.7.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3e8bfdd0e487acf992407a140d2589fe598238eaeffa3da8448d63a63cd363f8", size = 251511, upload_time = "2025-10-06T14:49:46.021Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e3/9a/201bb1e17e7af53139597069c375e7b0dcbd47594604f65c2d5359508566/multidict-6.7.0-cp312-cp312-win32.whl", hash = "sha256:dd32a49400a2c3d52088e120ee00c1e3576cbff7e10b98467962c74fdb762ed4", size = 41895, upload_time = "2025-10-06T14:49:48.718Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/46/e2/348cd32faad84eaf1d20cce80e2bb0ef8d312c55bca1f7fa9865e7770aaf/multidict-6.7.0-cp312-cp312-win_amd64.whl", hash = "sha256:92abb658ef2d7ef22ac9f8bb88e8b6c3e571671534e029359b6d9e845923eb1b", size = 46073, upload_time = "2025-10-06T14:49:50.28Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/25/ec/aad2613c1910dce907480e0c3aa306905830f25df2e54ccc9dea450cb5aa/multidict-6.7.0-cp312-cp312-win_arm64.whl", hash = "sha256:490dab541a6a642ce1a9d61a4781656b346a55c13038f0b1244653828e3a83ec", size = 43226, upload_time = "2025-10-06T14:49:52.304Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d2/86/33272a544eeb36d66e4d9a920602d1a2f57d4ebea4ef3cdfe5a912574c95/multidict-6.7.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:bee7c0588aa0076ce77c0ea5d19a68d76ad81fcd9fe8501003b9a24f9d4000f6", size = 76135, upload_time = "2025-10-06T14:49:54.26Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/91/1c/eb97db117a1ebe46d457a3d235a7b9d2e6dcab174f42d1b67663dd9e5371/multidict-6.7.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7ef6b61cad77091056ce0e7ce69814ef72afacb150b7ac6a3e9470def2198159", size = 45117, upload_time = "2025-10-06T14:49:55.82Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f1/d8/6c3442322e41fb1dd4de8bd67bfd11cd72352ac131f6368315617de752f1/multidict-6.7.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:9c0359b1ec12b1d6849c59f9d319610b7f20ef990a6d454ab151aa0e3b9f78ca", size = 43472, upload_time = "2025-10-06T14:49:57.048Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/75/3f/e2639e80325af0b6c6febdf8e57cc07043ff15f57fa1ef808f4ccb5ac4cd/multidict-6.7.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:cd240939f71c64bd658f186330603aac1a9a81bf6273f523fca63673cb7378a8", size = 249342, upload_time = "2025-10-06T14:49:58.368Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5d/cc/84e0585f805cbeaa9cbdaa95f9a3d6aed745b9d25700623ac89a6ecff400/multidict-6.7.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a60a4d75718a5efa473ebd5ab685786ba0c67b8381f781d1be14da49f1a2dc60", size = 257082, upload_time = "2025-10-06T14:49:59.89Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b0/9c/ac851c107c92289acbbf5cfb485694084690c1b17e555f44952c26ddc5bd/multidict-6.7.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:53a42d364f323275126aff81fb67c5ca1b7a04fda0546245730a55c8c5f24bc4", size = 240704, upload_time = "2025-10-06T14:50:01.485Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/50/cc/5f93e99427248c09da95b62d64b25748a5f5c98c7c2ab09825a1d6af0e15/multidict-6.7.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3b29b980d0ddbecb736735ee5bef69bb2ddca56eff603c86f3f29a1128299b4f", size = 266355, upload_time = "2025-10-06T14:50:02.955Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ec/0c/2ec1d883ceb79c6f7f6d7ad90c919c898f5d1c6ea96d322751420211e072/multidict-6.7.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f8a93b1c0ed2d04b97a5e9336fd2d33371b9a6e29ab7dd6503d63407c20ffbaf", size = 267259, upload_time = "2025-10-06T14:50:04.446Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c6/2d/f0b184fa88d6630aa267680bdb8623fb69cb0d024b8c6f0d23f9a0f406d3/multidict-6.7.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9ff96e8815eecacc6645da76c413eb3b3d34cfca256c70b16b286a687d013c32", size = 254903, upload_time = "2025-10-06T14:50:05.98Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/06/c9/11ea263ad0df7dfabcad404feb3c0dd40b131bc7f232d5537f2fb1356951/multidict-6.7.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:7516c579652f6a6be0e266aec0acd0db80829ca305c3d771ed898538804c2036", size = 252365, upload_time = "2025-10-06T14:50:07.511Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/41/88/d714b86ee2c17d6e09850c70c9d310abac3d808ab49dfa16b43aba9d53fd/multidict-6.7.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:040f393368e63fb0f3330e70c26bfd336656bed925e5cbe17c9da839a6ab13ec", size = 250062, upload_time = "2025-10-06T14:50:09.074Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/15/fe/ad407bb9e818c2b31383f6131ca19ea7e35ce93cf1310fce69f12e89de75/multidict-6.7.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:b3bc26a951007b1057a1c543af845f1c7e3e71cc240ed1ace7bf4484aa99196e", size = 249683, upload_time = "2025-10-06T14:50:10.714Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8c/a4/a89abdb0229e533fb925e7c6e5c40201c2873efebc9abaf14046a4536ee6/multidict-6.7.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:7b022717c748dd1992a83e219587aabe45980d88969f01b316e78683e6285f64", size = 261254, upload_time = "2025-10-06T14:50:12.28Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8d/aa/0e2b27bd88b40a4fb8dc53dd74eecac70edaa4c1dd0707eb2164da3675b3/multidict-6.7.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:9600082733859f00d79dee64effc7aef1beb26adb297416a4ad2116fd61374bd", size = 257967, upload_time = "2025-10-06T14:50:14.16Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d0/8e/0c67b7120d5d5f6d874ed85a085f9dc770a7f9d8813e80f44a9fec820bb7/multidict-6.7.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:94218fcec4d72bc61df51c198d098ce2b378e0ccbac41ddbed5ef44092913288", size = 250085, upload_time = "2025-10-06T14:50:15.639Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ba/55/b73e1d624ea4b8fd4dd07a3bb70f6e4c7c6c5d9d640a41c6ffe5cdbd2a55/multidict-6.7.0-cp313-cp313-win32.whl", hash = "sha256:a37bd74c3fa9d00be2d7b8eca074dc56bd8077ddd2917a839bd989612671ed17", size = 41713, upload_time = "2025-10-06T14:50:17.066Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/32/31/75c59e7d3b4205075b4c183fa4ca398a2daf2303ddf616b04ae6ef55cffe/multidict-6.7.0-cp313-cp313-win_amd64.whl", hash = "sha256:30d193c6cc6d559db42b6bcec8a5d395d34d60c9877a0b71ecd7c204fcf15390", size = 45915, upload_time = "2025-10-06T14:50:18.264Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/31/2a/8987831e811f1184c22bc2e45844934385363ee61c0a2dcfa8f71b87e608/multidict-6.7.0-cp313-cp313-win_arm64.whl", hash = "sha256:ea3334cabe4d41b7ccd01e4d349828678794edbc2d3ae97fc162a3312095092e", size = 43077, upload_time = "2025-10-06T14:50:19.853Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e8/68/7b3a5170a382a340147337b300b9eb25a9ddb573bcdfff19c0fa3f31ffba/multidict-6.7.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:ad9ce259f50abd98a1ca0aa6e490b58c316a0fce0617f609723e40804add2c00", size = 83114, upload_time = "2025-10-06T14:50:21.223Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/55/5c/3fa2d07c84df4e302060f555bbf539310980362236ad49f50eeb0a1c1eb9/multidict-6.7.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:07f5594ac6d084cbb5de2df218d78baf55ef150b91f0ff8a21cc7a2e3a5a58eb", size = 48442, upload_time = "2025-10-06T14:50:22.871Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fc/56/67212d33239797f9bd91962bb899d72bb0f4c35a8652dcdb8ed049bef878/multidict-6.7.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:0591b48acf279821a579282444814a2d8d0af624ae0bc600aa4d1b920b6e924b", size = 46885, upload_time = "2025-10-06T14:50:24.258Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/46/d1/908f896224290350721597a61a69cd19b89ad8ee0ae1f38b3f5cd12ea2ac/multidict-6.7.0-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:749a72584761531d2b9467cfbdfd29487ee21124c304c4b6cb760d8777b27f9c", size = 242588, upload_time = "2025-10-06T14:50:25.716Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ab/67/8604288bbd68680eee0ab568fdcb56171d8b23a01bcd5cb0c8fedf6e5d99/multidict-6.7.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b4c3d199f953acd5b446bf7c0de1fe25d94e09e79086f8dc2f48a11a129cdf1", size = 249966, upload_time = "2025-10-06T14:50:28.192Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/20/33/9228d76339f1ba51e3efef7da3ebd91964d3006217aae13211653193c3ff/multidict-6.7.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:9fb0211dfc3b51efea2f349ec92c114d7754dd62c01f81c3e32b765b70c45c9b", size = 228618, upload_time = "2025-10-06T14:50:29.82Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f8/2d/25d9b566d10cab1c42b3b9e5b11ef79c9111eaf4463b8c257a3bd89e0ead/multidict-6.7.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a027ec240fe73a8d6281872690b988eed307cd7d91b23998ff35ff577ca688b5", size = 257539, upload_time = "2025-10-06T14:50:31.731Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b6/b1/8d1a965e6637fc33de3c0d8f414485c2b7e4af00f42cab3d84e7b955c222/multidict-6.7.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1d964afecdf3a8288789df2f5751dc0a8261138c3768d9af117ed384e538fad", size = 256345, upload_time = "2025-10-06T14:50:33.26Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ba/0c/06b5a8adbdeedada6f4fb8d8f193d44a347223b11939b42953eeb6530b6b/multidict-6.7.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:caf53b15b1b7df9fbd0709aa01409000a2b4dd03a5f6f5cc548183c7c8f8b63c", size = 247934, upload_time = "2025-10-06T14:50:34.808Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8f/31/b2491b5fe167ca044c6eb4b8f2c9f3b8a00b24c432c365358eadac5d7625/multidict-6.7.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:654030da3197d927f05a536a66186070e98765aa5142794c9904555d3a9d8fb5", size = 245243, upload_time = "2025-10-06T14:50:36.436Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/61/1a/982913957cb90406c8c94f53001abd9eafc271cb3e70ff6371590bec478e/multidict-6.7.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:2090d3718829d1e484706a2f525e50c892237b2bf9b17a79b059cb98cddc2f10", size = 235878, upload_time = "2025-10-06T14:50:37.953Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/be/c0/21435d804c1a1cf7a2608593f4d19bca5bcbd7a81a70b253fdd1c12af9c0/multidict-6.7.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:2d2cfeec3f6f45651b3d408c4acec0ebf3daa9bc8a112a084206f5db5d05b754", size = 243452, upload_time = "2025-10-06T14:50:39.574Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/54/0a/4349d540d4a883863191be6eb9a928846d4ec0ea007d3dcd36323bb058ac/multidict-6.7.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:4ef089f985b8c194d341eb2c24ae6e7408c9a0e2e5658699c92f497437d88c3c", size = 252312, upload_time = "2025-10-06T14:50:41.612Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/26/64/d5416038dbda1488daf16b676e4dbfd9674dde10a0cc8f4fc2b502d8125d/multidict-6.7.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:e93a0617cd16998784bf4414c7e40f17a35d2350e5c6f0bd900d3a8e02bd3762", size = 246935, upload_time = "2025-10-06T14:50:43.972Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/9f/8c/8290c50d14e49f35e0bd4abc25e1bc7711149ca9588ab7d04f886cdf03d9/multidict-6.7.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:f0feece2ef8ebc42ed9e2e8c78fc4aa3cf455733b507c09ef7406364c94376c6", size = 243385, upload_time = "2025-10-06T14:50:45.648Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ef/a0/f83ae75e42d694b3fbad3e047670e511c138be747bc713cf1b10d5096416/multidict-6.7.0-cp313-cp313t-win32.whl", hash = "sha256:19a1d55338ec1be74ef62440ca9e04a2f001a04d0cc49a4983dc320ff0f3212d", size = 47777, upload_time = "2025-10-06T14:50:47.154Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/dc/80/9b174a92814a3830b7357307a792300f42c9e94664b01dee8e457551fa66/multidict-6.7.0-cp313-cp313t-win_amd64.whl", hash = "sha256:3da4fb467498df97e986af166b12d01f05d2e04f978a9c1c680ea1988e0bc4b6", size = 53104, upload_time = "2025-10-06T14:50:48.851Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/cc/28/04baeaf0428d95bb7a7bea0e691ba2f31394338ba424fb0679a9ed0f4c09/multidict-6.7.0-cp313-cp313t-win_arm64.whl", hash = "sha256:b4121773c49a0776461f4a904cdf6264c88e42218aaa8407e803ca8025872792", size = 45503, upload_time = "2025-10-06T14:50:50.16Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e2/b1/3da6934455dd4b261d4c72f897e3a5728eba81db59959f3a639245891baa/multidict-6.7.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3bab1e4aff7adaa34410f93b1f8e57c4b36b9af0426a76003f441ee1d3c7e842", size = 75128, upload_time = "2025-10-06T14:50:51.92Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/14/2c/f069cab5b51d175a1a2cb4ccdf7a2c2dabd58aa5bd933fa036a8d15e2404/multidict-6.7.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:b8512bac933afc3e45fb2b18da8e59b78d4f408399a960339598374d4ae3b56b", size = 44410, upload_time = "2025-10-06T14:50:53.275Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/42/e2/64bb41266427af6642b6b128e8774ed84c11b80a90702c13ac0a86bb10cc/multidict-6.7.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:79dcf9e477bc65414ebfea98ffd013cb39552b5ecd62908752e0e413d6d06e38", size = 43205, upload_time = "2025-10-06T14:50:54.911Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/02/68/6b086fef8a3f1a8541b9236c594f0c9245617c29841f2e0395d979485cde/multidict-6.7.0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:31bae522710064b5cbeddaf2e9f32b1abab70ac6ac91d42572502299e9953128", size = 245084, upload_time = "2025-10-06T14:50:56.369Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/15/ee/f524093232007cd7a75c1d132df70f235cfd590a7c9eaccd7ff422ef4ae8/multidict-6.7.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4a0df7ff02397bb63e2fd22af2c87dfa39e8c7f12947bc524dbdc528282c7e34", size = 252667, upload_time = "2025-10-06T14:50:57.991Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/02/a5/eeb3f43ab45878f1895118c3ef157a480db58ede3f248e29b5354139c2c9/multidict-6.7.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7a0222514e8e4c514660e182d5156a415c13ef0aabbd71682fc714e327b95e99", size = 233590, upload_time = "2025-10-06T14:50:59.589Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6a/1e/76d02f8270b97269d7e3dbd45644b1785bda457b474315f8cf999525a193/multidict-6.7.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2397ab4daaf2698eb51a76721e98db21ce4f52339e535725de03ea962b5a3202", size = 264112, upload_time = "2025-10-06T14:51:01.183Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/76/0b/c28a70ecb58963847c2a8efe334904cd254812b10e535aefb3bcce513918/multidict-6.7.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8891681594162635948a636c9fe0ff21746aeb3dd5463f6e25d9bea3a8a39ca1", size = 261194, upload_time = "2025-10-06T14:51:02.794Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b4/63/2ab26e4209773223159b83aa32721b4021ffb08102f8ac7d689c943fded1/multidict-6.7.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:18706cc31dbf402a7945916dd5cddf160251b6dab8a2c5f3d6d5a55949f676b3", size = 248510, upload_time = "2025-10-06T14:51:04.724Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/93/cd/06c1fa8282af1d1c46fd55c10a7930af652afdce43999501d4d68664170c/multidict-6.7.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f844a1bbf1d207dd311a56f383f7eda2d0e134921d45751842d8235e7778965d", size = 248395, upload_time = "2025-10-06T14:51:06.306Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/99/ac/82cb419dd6b04ccf9e7e61befc00c77614fc8134362488b553402ecd55ce/multidict-6.7.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:d4393e3581e84e5645506923816b9cc81f5609a778c7e7534054091acc64d1c6", size = 239520, upload_time = "2025-10-06T14:51:08.091Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fa/f3/a0f9bf09493421bd8716a362e0cd1d244f5a6550f5beffdd6b47e885b331/multidict-6.7.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:fbd18dc82d7bf274b37aa48d664534330af744e03bccf696d6f4c6042e7d19e7", size = 245479, upload_time = "2025-10-06T14:51:10.365Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8d/01/476d38fc73a212843f43c852b0eee266b6971f0e28329c2184a8df90c376/multidict-6.7.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:b6234e14f9314731ec45c42fc4554b88133ad53a09092cc48a88e771c125dadb", size = 258903, upload_time = "2025-10-06T14:51:12.466Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/49/6d/23faeb0868adba613b817d0e69c5f15531b24d462af8012c4f6de4fa8dc3/multidict-6.7.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:08d4379f9744d8f78d98c8673c06e202ffa88296f009c71bbafe8a6bf847d01f", size = 252333, upload_time = "2025-10-06T14:51:14.48Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/1e/cc/48d02ac22b30fa247f7dad82866e4b1015431092f4ba6ebc7e77596e0b18/multidict-6.7.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:9fe04da3f79387f450fd0061d4dd2e45a72749d31bf634aecc9e27f24fdc4b3f", size = 243411, upload_time = "2025-10-06T14:51:16.072Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/4a/03/29a8bf5a18abf1fe34535c88adbdfa88c9fb869b5a3b120692c64abe8284/multidict-6.7.0-cp314-cp314-win32.whl", hash = "sha256:fbafe31d191dfa7c4c51f7a6149c9fb7e914dcf9ffead27dcfd9f1ae382b3885", size = 40940, upload_time = "2025-10-06T14:51:17.544Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/82/16/7ed27b680791b939de138f906d5cf2b4657b0d45ca6f5dd6236fdddafb1a/multidict-6.7.0-cp314-cp314-win_amd64.whl", hash = "sha256:2f67396ec0310764b9222a1728ced1ab638f61aadc6226f17a71dd9324f9a99c", size = 45087, upload_time = "2025-10-06T14:51:18.875Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/cd/3c/e3e62eb35a1950292fe39315d3c89941e30a9d07d5d2df42965ab041da43/multidict-6.7.0-cp314-cp314-win_arm64.whl", hash = "sha256:ba672b26069957ee369cfa7fc180dde1fc6f176eaf1e6beaf61fbebbd3d9c000", size = 42368, upload_time = "2025-10-06T14:51:20.225Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8b/40/cd499bd0dbc5f1136726db3153042a735fffd0d77268e2ee20d5f33c010f/multidict-6.7.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:c1dcc7524066fa918c6a27d61444d4ee7900ec635779058571f70d042d86ed63", size = 82326, upload_time = "2025-10-06T14:51:21.588Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/13/8a/18e031eca251c8df76daf0288e6790561806e439f5ce99a170b4af30676b/multidict-6.7.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:27e0b36c2d388dc7b6ced3406671b401e84ad7eb0656b8f3a2f46ed0ce483718", size = 48065, upload_time = "2025-10-06T14:51:22.93Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/40/71/5e6701277470a87d234e433fb0a3a7deaf3bcd92566e421e7ae9776319de/multidict-6.7.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2a7baa46a22e77f0988e3b23d4ede5513ebec1929e34ee9495be535662c0dfe2", size = 46475, upload_time = "2025-10-06T14:51:24.352Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fe/6a/bab00cbab6d9cfb57afe1663318f72ec28289ea03fd4e8236bb78429893a/multidict-6.7.0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:7bf77f54997a9166a2f5675d1201520586439424c2511723a7312bdb4bcc034e", size = 239324, upload_time = "2025-10-06T14:51:25.822Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2a/5f/8de95f629fc22a7769ade8b41028e3e5a822c1f8904f618d175945a81ad3/multidict-6.7.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e011555abada53f1578d63389610ac8a5400fc70ce71156b0aa30d326f1a5064", size = 246877, upload_time = "2025-10-06T14:51:27.604Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/23/b4/38881a960458f25b89e9f4a4fdcb02ac101cfa710190db6e5528841e67de/multidict-6.7.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:28b37063541b897fd6a318007373930a75ca6d6ac7c940dbe14731ffdd8d498e", size = 225824, upload_time = "2025-10-06T14:51:29.664Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/1e/39/6566210c83f8a261575f18e7144736059f0c460b362e96e9cf797a24b8e7/multidict-6.7.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:05047ada7a2fde2631a0ed706f1fd68b169a681dfe5e4cf0f8e4cb6618bbc2cd", size = 253558, upload_time = "2025-10-06T14:51:31.684Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/00/a3/67f18315100f64c269f46e6c0319fa87ba68f0f64f2b8e7fd7c72b913a0b/multidict-6.7.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:716133f7d1d946a4e1b91b1756b23c088881e70ff180c24e864c26192ad7534a", size = 252339, upload_time = "2025-10-06T14:51:33.699Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c8/2a/1cb77266afee2458d82f50da41beba02159b1d6b1f7973afc9a1cad1499b/multidict-6.7.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d1bed1b467ef657f2a0ae62844a607909ef1c6889562de5e1d505f74457d0b96", size = 244895, upload_time = "2025-10-06T14:51:36.189Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/dd/72/09fa7dd487f119b2eb9524946ddd36e2067c08510576d43ff68469563b3b/multidict-6.7.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ca43bdfa5d37bd6aee89d85e1d0831fb86e25541be7e9d376ead1b28974f8e5e", size = 241862, upload_time = "2025-10-06T14:51:41.291Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/65/92/bc1f8bd0853d8669300f732c801974dfc3702c3eeadae2f60cef54dc69d7/multidict-6.7.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:44b546bd3eb645fd26fb949e43c02a25a2e632e2ca21a35e2e132c8105dc8599", size = 232376, upload_time = "2025-10-06T14:51:43.55Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/09/86/ac39399e5cb9d0c2ac8ef6e10a768e4d3bc933ac808d49c41f9dc23337eb/multidict-6.7.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:a6ef16328011d3f468e7ebc326f24c1445f001ca1dec335b2f8e66bed3006394", size = 240272, upload_time = "2025-10-06T14:51:45.265Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3d/b6/fed5ac6b8563ec72df6cb1ea8dac6d17f0a4a1f65045f66b6d3bf1497c02/multidict-6.7.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:5aa873cbc8e593d361ae65c68f85faadd755c3295ea2c12040ee146802f23b38", size = 248774, upload_time = "2025-10-06T14:51:46.836Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6b/8d/b954d8c0dc132b68f760aefd45870978deec6818897389dace00fcde32ff/multidict-6.7.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:3d7b6ccce016e29df4b7ca819659f516f0bc7a4b3efa3bb2012ba06431b044f9", size = 242731, upload_time = "2025-10-06T14:51:48.541Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/16/9d/a2dac7009125d3540c2f54e194829ea18ac53716c61b655d8ed300120b0f/multidict-6.7.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:171b73bd4ee683d307599b66793ac80981b06f069b62eea1c9e29c9241aa66b0", size = 240193, upload_time = "2025-10-06T14:51:50.355Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/39/ca/c05f144128ea232ae2178b008d5011d4e2cea86e4ee8c85c2631b1b94802/multidict-6.7.0-cp314-cp314t-win32.whl", hash = "sha256:b2d7f80c4e1fd010b07cb26820aae86b7e73b681ee4889684fb8d2d4537aab13", size = 48023, upload_time = "2025-10-06T14:51:51.883Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ba/8f/0a60e501584145588be1af5cc829265701ba3c35a64aec8e07cbb71d39bb/multidict-6.7.0-cp314-cp314t-win_amd64.whl", hash = "sha256:09929cab6fcb68122776d575e03c6cc64ee0b8fca48d17e135474b042ce515cd", size = 53507, upload_time = "2025-10-06T14:51:53.672Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/7f/ae/3148b988a9c6239903e786eac19c889fab607c31d6efa7fb2147e5680f23/multidict-6.7.0-cp314-cp314t-win_arm64.whl", hash = "sha256:cc41db090ed742f32bd2d2c721861725e6109681eddf835d0a82bd3a5c382827", size = 44804, upload_time = "2025-10-06T14:51:55.415Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b7/da/7d22601b625e241d4f23ef1ebff8acfc60da633c9e7e7922e24d10f592b3/multidict-6.7.0-py3-none-any.whl", hash = "sha256:394fc5c42a333c9ffc3e421a4c85e08580d990e08b99f6bf35b4132114c5dcb3", size = 12317, upload_time = "2025-10-06T14:52:29.272Z" }, +] + +[[package]] +name = "numpy" +version = "2.2.6" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +resolution-markers = [ + "python_full_version < '3.11'", +] +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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.5" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", +] +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/76/65/21b3bc86aac7b8f2862db1e808f1ea22b028e30a225a34a5ede9bf8678f2/numpy-2.3.5.tar.gz", hash = "sha256:784db1dcdab56bf0517743e746dfb0f885fc68d948aba86eeec2cba234bdf1c0", size = 20584950, upload_time = "2025-11-16T22:52:42.067Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/43/77/84dd1d2e34d7e2792a236ba180b5e8fcc1e3e414e761ce0253f63d7f572e/numpy-2.3.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:de5672f4a7b200c15a4127042170a694d4df43c992948f5e1af57f0174beed10", size = 17034641, upload_time = "2025-11-16T22:49:19.336Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2a/ea/25e26fa5837106cde46ae7d0b667e20f69cbbc0efd64cba8221411ab26ae/numpy-2.3.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:acfd89508504a19ed06ef963ad544ec6664518c863436306153e13e94605c218", size = 12528324, upload_time = "2025-11-16T22:49:22.582Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/4d/1a/e85f0eea4cf03d6a0228f5c0256b53f2df4bc794706e7df019fc622e47f1/numpy-2.3.5-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:ffe22d2b05504f786c867c8395de703937f934272eb67586817b46188b4ded6d", size = 5356872, upload_time = "2025-11-16T22:49:25.408Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5c/bb/35ef04afd567f4c989c2060cde39211e4ac5357155c1833bcd1166055c61/numpy-2.3.5-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:872a5cf366aec6bb1147336480fef14c9164b154aeb6542327de4970282cd2f5", size = 6893148, upload_time = "2025-11-16T22:49:27.549Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f2/2b/05bbeb06e2dff5eab512dfc678b1cc5ee94d8ac5956a0885c64b6b26252b/numpy-2.3.5-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3095bdb8dd297e5920b010e96134ed91d852d81d490e787beca7e35ae1d89cf7", size = 14557282, upload_time = "2025-11-16T22:49:30.964Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/65/fb/2b23769462b34398d9326081fad5655198fcf18966fcb1f1e49db44fbf31/numpy-2.3.5-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8cba086a43d54ca804ce711b2a940b16e452807acebe7852ff327f1ecd49b0d4", size = 16897903, upload_time = "2025-11-16T22:49:34.191Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ac/14/085f4cf05fc3f1e8aa95e85404e984ffca9b2275a5dc2b1aae18a67538b8/numpy-2.3.5-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6cf9b429b21df6b99f4dee7a1218b8b7ffbbe7df8764dc0bd60ce8a0708fed1e", size = 16341672, upload_time = "2025-11-16T22:49:37.2Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6f/3b/1f73994904142b2aa290449b3bb99772477b5fd94d787093e4f24f5af763/numpy-2.3.5-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:396084a36abdb603546b119d96528c2f6263921c50df3c8fd7cb28873a237748", size = 18838896, upload_time = "2025-11-16T22:49:39.727Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/cd/b9/cf6649b2124f288309ffc353070792caf42ad69047dcc60da85ee85fea58/numpy-2.3.5-cp311-cp311-win32.whl", hash = "sha256:b0c7088a73aef3d687c4deef8452a3ac7c1be4e29ed8bf3b366c8111128ac60c", size = 6563608, upload_time = "2025-11-16T22:49:42.079Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/aa/44/9fe81ae1dcc29c531843852e2874080dc441338574ccc4306b39e2ff6e59/numpy-2.3.5-cp311-cp311-win_amd64.whl", hash = "sha256:a414504bef8945eae5f2d7cb7be2d4af77c5d1cb5e20b296c2c25b61dff2900c", size = 13078442, upload_time = "2025-11-16T22:49:43.99Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6d/a7/f99a41553d2da82a20a2f22e93c94f928e4490bb447c9ff3c4ff230581d3/numpy-2.3.5-cp311-cp311-win_arm64.whl", hash = "sha256:0cd00b7b36e35398fa2d16af7b907b65304ef8bb4817a550e06e5012929830fa", size = 10458555, upload_time = "2025-11-16T22:49:47.092Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/44/37/e669fe6cbb2b96c62f6bbedc6a81c0f3b7362f6a59230b23caa673a85721/numpy-2.3.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:74ae7b798248fe62021dbf3c914245ad45d1a6b0cb4a29ecb4b31d0bfbc4cc3e", size = 16733873, upload_time = "2025-11-16T22:49:49.84Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c5/65/df0db6c097892c9380851ab9e44b52d4f7ba576b833996e0080181c0c439/numpy-2.3.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ee3888d9ff7c14604052b2ca5535a30216aa0a58e948cdd3eeb8d3415f638769", size = 12259838, upload_time = "2025-11-16T22:49:52.863Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5b/e1/1ee06e70eb2136797abe847d386e7c0e830b67ad1d43f364dd04fa50d338/numpy-2.3.5-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:612a95a17655e213502f60cfb9bf9408efdc9eb1d5f50535cc6eb365d11b42b5", size = 5088378, upload_time = "2025-11-16T22:49:55.055Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6d/9c/1ca85fb86708724275103b81ec4cf1ac1d08f465368acfc8da7ab545bdae/numpy-2.3.5-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:3101e5177d114a593d79dd79658650fe28b5a0d8abeb8ce6f437c0e6df5be1a4", size = 6628559, upload_time = "2025-11-16T22:49:57.371Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/74/78/fcd41e5a0ce4f3f7b003da85825acddae6d7ecb60cf25194741b036ca7d6/numpy-2.3.5-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b973c57ff8e184109db042c842423ff4f60446239bd585a5131cc47f06f789d", size = 14250702, upload_time = "2025-11-16T22:49:59.632Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b6/23/2a1b231b8ff672b4c450dac27164a8b2ca7d9b7144f9c02d2396518352eb/numpy-2.3.5-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0d8163f43acde9a73c2a33605353a4f1bc4798745a8b1d73183b28e5b435ae28", size = 16606086, upload_time = "2025-11-16T22:50:02.127Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a0/c5/5ad26fbfbe2012e190cc7d5003e4d874b88bb18861d0829edc140a713021/numpy-2.3.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:51c1e14eb1e154ebd80e860722f9e6ed6ec89714ad2db2d3aa33c31d7c12179b", size = 16025985, upload_time = "2025-11-16T22:50:04.536Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d2/fa/dd48e225c46c819288148d9d060b047fd2a6fb1eb37eae25112ee4cb4453/numpy-2.3.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b46b4ec24f7293f23adcd2d146960559aaf8020213de8ad1909dba6c013bf89c", size = 18542976, upload_time = "2025-11-16T22:50:07.557Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/05/79/ccbd23a75862d95af03d28b5c6901a1b7da4803181513d52f3b86ed9446e/numpy-2.3.5-cp312-cp312-win32.whl", hash = "sha256:3997b5b3c9a771e157f9aae01dd579ee35ad7109be18db0e85dbdbe1de06e952", size = 6285274, upload_time = "2025-11-16T22:50:10.746Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2d/57/8aeaf160312f7f489dea47ab61e430b5cb051f59a98ae68b7133ce8fa06a/numpy-2.3.5-cp312-cp312-win_amd64.whl", hash = "sha256:86945f2ee6d10cdfd67bcb4069c1662dd711f7e2a4343db5cecec06b87cf31aa", size = 12782922, upload_time = "2025-11-16T22:50:12.811Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/78/a6/aae5cc2ca78c45e64b9ef22f089141d661516856cf7c8a54ba434576900d/numpy-2.3.5-cp312-cp312-win_arm64.whl", hash = "sha256:f28620fe26bee16243be2b7b874da327312240a7cdc38b769a697578d2100013", size = 10194667, upload_time = "2025-11-16T22:50:16.16Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/db/69/9cde09f36da4b5a505341180a3f2e6fadc352fd4d2b7096ce9778db83f1a/numpy-2.3.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d0f23b44f57077c1ede8c5f26b30f706498b4862d3ff0a7298b8411dd2f043ff", size = 16728251, upload_time = "2025-11-16T22:50:19.013Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/79/fb/f505c95ceddd7027347b067689db71ca80bd5ecc926f913f1a23e65cf09b/numpy-2.3.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:aa5bc7c5d59d831d9773d1170acac7893ce3a5e130540605770ade83280e7188", size = 12254652, upload_time = "2025-11-16T22:50:21.487Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/78/da/8c7738060ca9c31b30e9301ee0cf6c5ffdbf889d9593285a1cead337f9a5/numpy-2.3.5-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:ccc933afd4d20aad3c00bcef049cb40049f7f196e0397f1109dba6fed63267b0", size = 5083172, upload_time = "2025-11-16T22:50:24.562Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a4/b4/ee5bb2537fb9430fd2ef30a616c3672b991a4129bb1c7dcc42aa0abbe5d7/numpy-2.3.5-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:afaffc4393205524af9dfa400fa250143a6c3bc646c08c9f5e25a9f4b4d6a903", size = 6622990, upload_time = "2025-11-16T22:50:26.47Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/95/03/dc0723a013c7d7c19de5ef29e932c3081df1c14ba582b8b86b5de9db7f0f/numpy-2.3.5-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9c75442b2209b8470d6d5d8b1c25714270686f14c749028d2199c54e29f20b4d", size = 14248902, upload_time = "2025-11-16T22:50:28.861Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f5/10/ca162f45a102738958dcec8023062dad0cbc17d1ab99d68c4e4a6c45fb2b/numpy-2.3.5-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11e06aa0af8c0f05104d56450d6093ee639e15f24ecf62d417329d06e522e017", size = 16597430, upload_time = "2025-11-16T22:50:31.56Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2a/51/c1e29be863588db58175175f057286900b4b3327a1351e706d5e0f8dd679/numpy-2.3.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ed89927b86296067b4f81f108a2271d8926467a8868e554eaf370fc27fa3ccaf", size = 16024551, upload_time = "2025-11-16T22:50:34.242Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/83/68/8236589d4dbb87253d28259d04d9b814ec0ecce7cb1c7fed29729f4c3a78/numpy-2.3.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:51c55fe3451421f3a6ef9a9c1439e82101c57a2c9eab9feb196a62b1a10b58ce", size = 18533275, upload_time = "2025-11-16T22:50:37.651Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/40/56/2932d75b6f13465239e3b7b7e511be27f1b8161ca2510854f0b6e521c395/numpy-2.3.5-cp313-cp313-win32.whl", hash = "sha256:1978155dd49972084bd6ef388d66ab70f0c323ddee6f693d539376498720fb7e", size = 6277637, upload_time = "2025-11-16T22:50:40.11Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0c/88/e2eaa6cffb115b85ed7c7c87775cb8bcf0816816bc98ca8dbfa2ee33fe6e/numpy-2.3.5-cp313-cp313-win_amd64.whl", hash = "sha256:00dc4e846108a382c5869e77c6ed514394bdeb3403461d25a829711041217d5b", size = 12779090, upload_time = "2025-11-16T22:50:42.503Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8f/88/3f41e13a44ebd4034ee17baa384acac29ba6a4fcc2aca95f6f08ca0447d1/numpy-2.3.5-cp313-cp313-win_arm64.whl", hash = "sha256:0472f11f6ec23a74a906a00b48a4dcf3849209696dff7c189714511268d103ae", size = 10194710, upload_time = "2025-11-16T22:50:44.971Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/13/cb/71744144e13389d577f867f745b7df2d8489463654a918eea2eeb166dfc9/numpy-2.3.5-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:414802f3b97f3c1eef41e530aaba3b3c1620649871d8cb38c6eaff034c2e16bd", size = 16827292, upload_time = "2025-11-16T22:50:47.715Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/71/80/ba9dc6f2a4398e7f42b708a7fdc841bb638d353be255655498edbf9a15a8/numpy-2.3.5-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5ee6609ac3604fa7780e30a03e5e241a7956f8e2fcfe547d51e3afa5247ac47f", size = 12378897, upload_time = "2025-11-16T22:50:51.327Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2e/6d/db2151b9f64264bcceccd51741aa39b50150de9b602d98ecfe7e0c4bff39/numpy-2.3.5-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:86d835afea1eaa143012a2d7a3f45a3adce2d7adc8b4961f0b362214d800846a", size = 5207391, upload_time = "2025-11-16T22:50:54.542Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/80/ae/429bacace5ccad48a14c4ae5332f6aa8ab9f69524193511d60ccdfdc65fa/numpy-2.3.5-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:30bc11310e8153ca664b14c5f1b73e94bd0503681fcf136a163de856f3a50139", size = 6721275, upload_time = "2025-11-16T22:50:56.794Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/74/5b/1919abf32d8722646a38cd527bc3771eb229a32724ee6ba340ead9b92249/numpy-2.3.5-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1062fde1dcf469571705945b0f221b73928f34a20c904ffb45db101907c3454e", size = 14306855, upload_time = "2025-11-16T22:50:59.208Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a5/87/6831980559434973bebc30cd9c1f21e541a0f2b0c280d43d3afd909b66d0/numpy-2.3.5-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ce581db493ea1a96c0556360ede6607496e8bf9b3a8efa66e06477267bc831e9", size = 16657359, upload_time = "2025-11-16T22:51:01.991Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/dd/91/c797f544491ee99fd00495f12ebb7802c440c1915811d72ac5b4479a3356/numpy-2.3.5-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:cc8920d2ec5fa99875b670bb86ddeb21e295cb07aa331810d9e486e0b969d946", size = 16093374, upload_time = "2025-11-16T22:51:05.291Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/74/a6/54da03253afcbe7a72785ec4da9c69fb7a17710141ff9ac5fcb2e32dbe64/numpy-2.3.5-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:9ee2197ef8c4f0dfe405d835f3b6a14f5fee7782b5de51ba06fb65fc9b36e9f1", size = 18594587, upload_time = "2025-11-16T22:51:08.585Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/80/e9/aff53abbdd41b0ecca94285f325aff42357c6b5abc482a3fcb4994290b18/numpy-2.3.5-cp313-cp313t-win32.whl", hash = "sha256:70b37199913c1bd300ff6e2693316c6f869c7ee16378faf10e4f5e3275b299c3", size = 6405940, upload_time = "2025-11-16T22:51:11.541Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d5/81/50613fec9d4de5480de18d4f8ef59ad7e344d497edbef3cfd80f24f98461/numpy-2.3.5-cp313-cp313t-win_amd64.whl", hash = "sha256:b501b5fa195cc9e24fe102f21ec0a44dffc231d2af79950b451e0d99cea02234", size = 12920341, upload_time = "2025-11-16T22:51:14.312Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/bb/ab/08fd63b9a74303947f34f0bd7c5903b9c5532c2d287bead5bdf4c556c486/numpy-2.3.5-cp313-cp313t-win_arm64.whl", hash = "sha256:a80afd79f45f3c4a7d341f13acbe058d1ca8ac017c165d3fa0d3de6bc1a079d7", size = 10262507, upload_time = "2025-11-16T22:51:16.846Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ba/97/1a914559c19e32d6b2e233cf9a6a114e67c856d35b1d6babca571a3e880f/numpy-2.3.5-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:bf06bc2af43fa8d32d30fae16ad965663e966b1a3202ed407b84c989c3221e82", size = 16735706, upload_time = "2025-11-16T22:51:19.558Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/57/d4/51233b1c1b13ecd796311216ae417796b88b0616cfd8a33ae4536330748a/numpy-2.3.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:052e8c42e0c49d2575621c158934920524f6c5da05a1d3b9bab5d8e259e045f0", size = 12264507, upload_time = "2025-11-16T22:51:22.492Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/45/98/2fe46c5c2675b8306d0b4a3ec3494273e93e1226a490f766e84298576956/numpy-2.3.5-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:1ed1ec893cff7040a02c8aa1c8611b94d395590d553f6b53629a4461dc7f7b63", size = 5093049, upload_time = "2025-11-16T22:51:25.171Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ce/0e/0698378989bb0ac5f1660c81c78ab1fe5476c1a521ca9ee9d0710ce54099/numpy-2.3.5-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:2dcd0808a421a482a080f89859a18beb0b3d1e905b81e617a188bd80422d62e9", size = 6626603, upload_time = "2025-11-16T22:51:27Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5e/a6/9ca0eecc489640615642a6cbc0ca9e10df70df38c4d43f5a928ff18d8827/numpy-2.3.5-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:727fd05b57df37dc0bcf1a27767a3d9a78cbbc92822445f32cc3436ba797337b", size = 14262696, upload_time = "2025-11-16T22:51:29.402Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c8/f6/07ec185b90ec9d7217a00eeeed7383b73d7e709dae2a9a021b051542a708/numpy-2.3.5-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fffe29a1ef00883599d1dc2c51aa2e5d80afe49523c261a74933df395c15c520", size = 16597350, upload_time = "2025-11-16T22:51:32.167Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/75/37/164071d1dde6a1a84c9b8e5b414fa127981bad47adf3a6b7e23917e52190/numpy-2.3.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8f7f0e05112916223d3f438f293abf0727e1181b5983f413dfa2fefc4098245c", size = 16040190, upload_time = "2025-11-16T22:51:35.403Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/08/3c/f18b82a406b04859eb026d204e4e1773eb41c5be58410f41ffa511d114ae/numpy-2.3.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2e2eb32ddb9ccb817d620ac1d8dae7c3f641c1e5f55f531a33e8ab97960a75b8", size = 18536749, upload_time = "2025-11-16T22:51:39.698Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/40/79/f82f572bf44cf0023a2fe8588768e23e1592585020d638999f15158609e1/numpy-2.3.5-cp314-cp314-win32.whl", hash = "sha256:66f85ce62c70b843bab1fb14a05d5737741e74e28c7b8b5a064de10142fad248", size = 6335432, upload_time = "2025-11-16T22:51:42.476Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a3/2e/235b4d96619931192c91660805e5e49242389742a7a82c27665021db690c/numpy-2.3.5-cp314-cp314-win_amd64.whl", hash = "sha256:e6a0bc88393d65807d751a614207b7129a310ca4fe76a74e5c7da5fa5671417e", size = 12919388, upload_time = "2025-11-16T22:51:45.275Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/07/2b/29fd75ce45d22a39c61aad74f3d718e7ab67ccf839ca8b60866054eb15f8/numpy-2.3.5-cp314-cp314-win_arm64.whl", hash = "sha256:aeffcab3d4b43712bb7a60b65f6044d444e75e563ff6180af8f98dd4b905dfd2", size = 10476651, upload_time = "2025-11-16T22:51:47.749Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/17/e1/f6a721234ebd4d87084cfa68d081bcba2f5cfe1974f7de4e0e8b9b2a2ba1/numpy-2.3.5-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:17531366a2e3a9e30762c000f2c43a9aaa05728712e25c11ce1dbe700c53ad41", size = 16834503, upload_time = "2025-11-16T22:51:50.443Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5c/1c/baf7ffdc3af9c356e1c135e57ab7cf8d247931b9554f55c467efe2c69eff/numpy-2.3.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d21644de1b609825ede2f48be98dfde4656aefc713654eeee280e37cadc4e0ad", size = 12381612, upload_time = "2025-11-16T22:51:53.609Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/74/91/f7f0295151407ddc9ba34e699013c32c3c91944f9b35fcf9281163dc1468/numpy-2.3.5-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:c804e3a5aba5460c73955c955bdbd5c08c354954e9270a2c1565f62e866bdc39", size = 5210042, upload_time = "2025-11-16T22:51:56.213Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2e/3b/78aebf345104ec50dd50a4d06ddeb46a9ff5261c33bcc58b1c4f12f85ec2/numpy-2.3.5-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:cc0a57f895b96ec78969c34f682c602bf8da1a0270b09bc65673df2e7638ec20", size = 6724502, upload_time = "2025-11-16T22:51:58.584Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/02/c6/7c34b528740512e57ef1b7c8337ab0b4f0bddf34c723b8996c675bc2bc91/numpy-2.3.5-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:900218e456384ea676e24ea6a0417f030a3b07306d29d7ad843957b40a9d8d52", size = 14308962, upload_time = "2025-11-16T22:52:01.698Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/80/35/09d433c5262bc32d725bafc619e095b6a6651caf94027a03da624146f655/numpy-2.3.5-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:09a1bea522b25109bf8e6f3027bd810f7c1085c64a0c7ce050c1676ad0ba010b", size = 16655054, upload_time = "2025-11-16T22:52:04.267Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/7a/ab/6a7b259703c09a88804fa2430b43d6457b692378f6b74b356155283566ac/numpy-2.3.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:04822c00b5fd0323c8166d66c701dc31b7fbd252c100acd708c48f763968d6a3", size = 16091613, upload_time = "2025-11-16T22:52:08.651Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c2/88/330da2071e8771e60d1038166ff9d73f29da37b01ec3eb43cb1427464e10/numpy-2.3.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d6889ec4ec662a1a37eb4b4fb26b6100841804dac55bd9df579e326cdc146227", size = 18591147, upload_time = "2025-11-16T22:52:11.453Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/51/41/851c4b4082402d9ea860c3626db5d5df47164a712cb23b54be028b184c1c/numpy-2.3.5-cp314-cp314t-win32.whl", hash = "sha256:93eebbcf1aafdf7e2ddd44c2923e2672e1010bddc014138b229e49725b4d6be5", size = 6479806, upload_time = "2025-11-16T22:52:14.641Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/90/30/d48bde1dfd93332fa557cff1972fbc039e055a52021fbef4c2c4b1eefd17/numpy-2.3.5-cp314-cp314t-win_amd64.whl", hash = "sha256:c8a9958e88b65c3b27e22ca2a076311636850b612d6bbfb76e8d156aacde2aaf", size = 13105760, upload_time = "2025-11-16T22:52:17.975Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2d/fd/4b5eb0b3e888d86aee4d198c23acec7d214baaf17ea93c1adec94c9518b9/numpy-2.3.5-cp314-cp314t-win_arm64.whl", hash = "sha256:6203fdf9f3dc5bdaed7319ad8698e685c7a3be10819f41d32a0723e611733b42", size = 10545459, upload_time = "2025-11-16T22:52:20.55Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c6/65/f9dea8e109371ade9c782b4e4756a82edf9d3366bca495d84d79859a0b79/numpy-2.3.5-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:f0963b55cdd70fad460fa4c1341f12f976bb26cb66021a5580329bd498988310", size = 16910689, upload_time = "2025-11-16T22:52:23.247Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/00/4f/edb00032a8fb92ec0a679d3830368355da91a69cab6f3e9c21b64d0bb986/numpy-2.3.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:f4255143f5160d0de972d28c8f9665d882b5f61309d8362fdd3e103cf7bf010c", size = 12457053, upload_time = "2025-11-16T22:52:26.367Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/16/a4/e8a53b5abd500a63836a29ebe145fc1ab1f2eefe1cfe59276020373ae0aa/numpy-2.3.5-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:a4b9159734b326535f4dd01d947f919c6eefd2d9827466a696c44ced82dfbc18", size = 5285635, upload_time = "2025-11-16T22:52:29.266Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a3/2f/37eeb9014d9c8b3e9c55bc599c68263ca44fdbc12a93e45a21d1d56df737/numpy-2.3.5-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:2feae0d2c91d46e59fcd62784a3a83b3fb677fead592ce51b5a6fbb4f95965ff", size = 6801770, upload_time = "2025-11-16T22:52:31.421Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/7d/e4/68d2f474df2cb671b2b6c2986a02e520671295647dad82484cde80ca427b/numpy-2.3.5-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ffac52f28a7849ad7576293c0cb7b9f08304e8f7d738a8cb8a90ec4c55a998eb", size = 14391768, upload_time = "2025-11-16T22:52:33.593Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b8/50/94ccd8a2b141cb50651fddd4f6a48874acb3c91c8f0842b08a6afc4b0b21/numpy-2.3.5-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:63c0e9e7eea69588479ebf4a8a270d5ac22763cc5854e9a7eae952a3908103f7", size = 16729263, upload_time = "2025-11-16T22:52:36.369Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2d/ee/346fa473e666fe14c52fcdd19ec2424157290a032d4c41f98127bfb31ac7/numpy-2.3.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:f16417ec91f12f814b10bafe79ef77e70113a2f5f7018640e7425ff979253425", size = 12967213, upload_time = "2025-11-16T22:52:39.38Z" }, +] + +[[package]] +name = "openai" +version = "2.9.0" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +dependencies = [ + { name = "anyio" }, + { name = "distro" }, + { name = "httpx" }, + { name = "jiter" }, + { name = "pydantic" }, + { name = "sniffio" }, + { name = "tqdm" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/09/48/516290f38745cc1e72856f50e8afed4a7f9ac396a5a18f39e892ab89dfc2/openai-2.9.0.tar.gz", hash = "sha256:b52ec65727fc8f1eed2fbc86c8eac0998900c7ef63aa2eb5c24b69717c56fa5f", size = 608202, upload_time = "2025-12-04T18:15:09.01Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/59/fd/ae2da789cd923dd033c99b8d544071a827c92046b150db01cfa5cea5b3fd/openai-2.9.0-py3-none-any.whl", hash = "sha256:0d168a490fbb45630ad508a6f3022013c155a68fd708069b6a1a01a5e8f0ffad", size = 1030836, upload_time = "2025-12-04T18:15:07.063Z" }, +] + +[[package]] +name = "packaging" +version = "25.0" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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.3" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +dependencies = [ + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }, marker = "python_full_version < '3.11'" }, + { name = "numpy", version = "2.3.5", source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "python-dateutil" }, + { name = "pytz" }, + { name = "tzdata" }, +] +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/33/01/d40b85317f86cf08d853a4f495195c73815fdf205eef3993821720274518/pandas-2.3.3.tar.gz", hash = "sha256:e05e1af93b977f7eafa636d043f9f94c7ee3ac81af99c13508215942e64c993b", size = 4495223, upload_time = "2025-09-29T23:34:51.853Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3d/f7/f425a00df4fcc22b292c6895c6831c0c8ae1d9fac1e024d16f98a9ce8749/pandas-2.3.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:376c6446ae31770764215a6c937f72d917f214b43560603cd60da6408f183b6c", size = 11555763, upload_time = "2025-09-29T23:16:53.287Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/13/4f/66d99628ff8ce7857aca52fed8f0066ce209f96be2fede6cef9f84e8d04f/pandas-2.3.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e19d192383eab2f4ceb30b412b22ea30690c9e618f78870357ae1d682912015a", size = 10801217, upload_time = "2025-09-29T23:17:04.522Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/1d/03/3fc4a529a7710f890a239cc496fc6d50ad4a0995657dccc1d64695adb9f4/pandas-2.3.3-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5caf26f64126b6c7aec964f74266f435afef1c1b13da3b0636c7518a1fa3e2b1", size = 12148791, upload_time = "2025-09-29T23:17:18.444Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/40/a8/4dac1f8f8235e5d25b9955d02ff6f29396191d4e665d71122c3722ca83c5/pandas-2.3.3-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dd7478f1463441ae4ca7308a70e90b33470fa593429f9d4c578dd00d1fa78838", size = 12769373, upload_time = "2025-09-29T23:17:35.846Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/df/91/82cc5169b6b25440a7fc0ef3a694582418d875c8e3ebf796a6d6470aa578/pandas-2.3.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:4793891684806ae50d1288c9bae9330293ab4e083ccd1c5e383c34549c6e4250", size = 13200444, upload_time = "2025-09-29T23:17:49.341Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/10/ae/89b3283800ab58f7af2952704078555fa60c807fff764395bb57ea0b0dbd/pandas-2.3.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:28083c648d9a99a5dd035ec125d42439c6c1c525098c58af0fc38dd1a7a1b3d4", size = 13858459, upload_time = "2025-09-29T23:18:03.722Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/85/72/530900610650f54a35a19476eca5104f38555afccda1aa11a92ee14cb21d/pandas-2.3.3-cp310-cp310-win_amd64.whl", hash = "sha256:503cf027cf9940d2ceaa1a93cfb5f8c8c7e6e90720a2850378f0b3f3b1e06826", size = 11346086, upload_time = "2025-09-29T23:18:18.505Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c1/fa/7ac648108144a095b4fb6aa3de1954689f7af60a14cf25583f4960ecb878/pandas-2.3.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:602b8615ebcc4a0c1751e71840428ddebeb142ec02c786e8ad6b1ce3c8dec523", size = 11578790, upload_time = "2025-09-29T23:18:30.065Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/9b/35/74442388c6cf008882d4d4bdfc4109be87e9b8b7ccd097ad1e7f006e2e95/pandas-2.3.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:8fe25fc7b623b0ef6b5009149627e34d2a4657e880948ec3c840e9402e5c1b45", size = 10833831, upload_time = "2025-09-29T23:38:56.071Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fe/e4/de154cbfeee13383ad58d23017da99390b91d73f8c11856f2095e813201b/pandas-2.3.3-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b468d3dad6ff947df92dcb32ede5b7bd41a9b3cceef0a30ed925f6d01fb8fa66", size = 12199267, upload_time = "2025-09-29T23:18:41.627Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/bf/c9/63f8d545568d9ab91476b1818b4741f521646cbdd151c6efebf40d6de6f7/pandas-2.3.3-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b98560e98cb334799c0b07ca7967ac361a47326e9b4e5a7dfb5ab2b1c9d35a1b", size = 12789281, upload_time = "2025-09-29T23:18:56.834Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f2/00/a5ac8c7a0e67fd1a6059e40aa08fa1c52cc00709077d2300e210c3ce0322/pandas-2.3.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37b5848ba49824e5c30bedb9c830ab9b7751fd049bc7914533e01c65f79791", size = 13240453, upload_time = "2025-09-29T23:19:09.247Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/27/4d/5c23a5bc7bd209231618dd9e606ce076272c9bc4f12023a70e03a86b4067/pandas-2.3.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:db4301b2d1f926ae677a751eb2bd0e8c5f5319c9cb3f88b0becbbb0b07b34151", size = 13890361, upload_time = "2025-09-29T23:19:25.342Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8e/59/712db1d7040520de7a4965df15b774348980e6df45c129b8c64d0dbe74ef/pandas-2.3.3-cp311-cp311-win_amd64.whl", hash = "sha256:f086f6fe114e19d92014a1966f43a3e62285109afe874f067f5abbdcbb10e59c", size = 11348702, upload_time = "2025-09-29T23:19:38.296Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/9c/fb/231d89e8637c808b997d172b18e9d4a4bc7bf31296196c260526055d1ea0/pandas-2.3.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d21f6d74eb1725c2efaa71a2bfc661a0689579b58e9c0ca58a739ff0b002b53", size = 11597846, upload_time = "2025-09-29T23:19:48.856Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5c/bd/bf8064d9cfa214294356c2d6702b716d3cf3bb24be59287a6a21e24cae6b/pandas-2.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3fd2f887589c7aa868e02632612ba39acb0b8948faf5cc58f0850e165bd46f35", size = 10729618, upload_time = "2025-09-29T23:39:08.659Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/57/56/cf2dbe1a3f5271370669475ead12ce77c61726ffd19a35546e31aa8edf4e/pandas-2.3.3-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ecaf1e12bdc03c86ad4a7ea848d66c685cb6851d807a26aa245ca3d2017a1908", size = 11737212, upload_time = "2025-09-29T23:19:59.765Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e5/63/cd7d615331b328e287d8233ba9fdf191a9c2d11b6af0c7a59cfcec23de68/pandas-2.3.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b3d11d2fda7eb164ef27ffc14b4fcab16a80e1ce67e9f57e19ec0afaf715ba89", size = 12362693, upload_time = "2025-09-29T23:20:14.098Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a6/de/8b1895b107277d52f2b42d3a6806e69cfef0d5cf1d0ba343470b9d8e0a04/pandas-2.3.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a68e15f780eddf2b07d242e17a04aa187a7ee12b40b930bfdd78070556550e98", size = 12771002, upload_time = "2025-09-29T23:20:26.76Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/87/21/84072af3187a677c5893b170ba2c8fbe450a6ff911234916da889b698220/pandas-2.3.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:371a4ab48e950033bcf52b6527eccb564f52dc826c02afd9a1bc0ab731bba084", size = 13450971, upload_time = "2025-09-29T23:20:41.344Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/86/41/585a168330ff063014880a80d744219dbf1dd7a1c706e75ab3425a987384/pandas-2.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:a16dcec078a01eeef8ee61bf64074b4e524a2a3f4b3be9326420cabe59c4778b", size = 10992722, upload_time = "2025-09-29T23:20:54.139Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/cd/4b/18b035ee18f97c1040d94debd8f2e737000ad70ccc8f5513f4eefad75f4b/pandas-2.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:56851a737e3470de7fa88e6131f41281ed440d29a9268dcbf0002da5ac366713", size = 11544671, upload_time = "2025-09-29T23:21:05.024Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/31/94/72fac03573102779920099bcac1c3b05975c2cb5f01eac609faf34bed1ca/pandas-2.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bdcd9d1167f4885211e401b3036c0c8d9e274eee67ea8d0758a256d60704cfe8", size = 10680807, upload_time = "2025-09-29T23:21:15.979Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/16/87/9472cf4a487d848476865321de18cc8c920b8cab98453ab79dbbc98db63a/pandas-2.3.3-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e32e7cc9af0f1cc15548288a51a3b681cc2a219faa838e995f7dc53dbab1062d", size = 11709872, upload_time = "2025-09-29T23:21:27.165Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/15/07/284f757f63f8a8d69ed4472bfd85122bd086e637bf4ed09de572d575a693/pandas-2.3.3-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:318d77e0e42a628c04dc56bcef4b40de67918f7041c2b061af1da41dcff670ac", size = 12306371, upload_time = "2025-09-29T23:21:40.532Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/33/81/a3afc88fca4aa925804a27d2676d22dcd2031c2ebe08aabd0ae55b9ff282/pandas-2.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4e0a175408804d566144e170d0476b15d78458795bb18f1304fb94160cabf40c", size = 12765333, upload_time = "2025-09-29T23:21:55.77Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8d/0f/b4d4ae743a83742f1153464cf1a8ecfafc3ac59722a0b5c8602310cb7158/pandas-2.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:93c2d9ab0fc11822b5eece72ec9587e172f63cff87c00b062f6e37448ced4493", size = 13418120, upload_time = "2025-09-29T23:22:10.109Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/4f/c7/e54682c96a895d0c808453269e0b5928a07a127a15704fedb643e9b0a4c8/pandas-2.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:f8bfc0e12dc78f777f323f55c58649591b2cd0c43534e8355c51d3fede5f4dee", size = 10993991, upload_time = "2025-09-29T23:25:04.889Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f9/ca/3f8d4f49740799189e1395812f3bf23b5e8fc7c190827d55a610da72ce55/pandas-2.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:75ea25f9529fdec2d2e93a42c523962261e567d250b0013b16210e1d40d7c2e5", size = 12048227, upload_time = "2025-09-29T23:22:24.343Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0e/5a/f43efec3e8c0cc92c4663ccad372dbdff72b60bdb56b2749f04aa1d07d7e/pandas-2.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:74ecdf1d301e812db96a465a525952f4dde225fdb6d8e5a521d47e1f42041e21", size = 11411056, upload_time = "2025-09-29T23:22:37.762Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/46/b1/85331edfc591208c9d1a63a06baa67b21d332e63b7a591a5ba42a10bb507/pandas-2.3.3-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6435cb949cb34ec11cc9860246ccb2fdc9ecd742c12d3304989017d53f039a78", size = 11645189, upload_time = "2025-09-29T23:22:51.688Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/44/23/78d645adc35d94d1ac4f2a3c4112ab6f5b8999f4898b8cdf01252f8df4a9/pandas-2.3.3-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:900f47d8f20860de523a1ac881c4c36d65efcb2eb850e6948140fa781736e110", size = 12121912, upload_time = "2025-09-29T23:23:05.042Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/53/da/d10013df5e6aaef6b425aa0c32e1fc1f3e431e4bcabd420517dceadce354/pandas-2.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a45c765238e2ed7d7c608fc5bc4a6f88b642f2f01e70c0c23d2224dd21829d86", size = 12712160, upload_time = "2025-09-29T23:23:28.57Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/bd/17/e756653095a083d8a37cbd816cb87148debcfcd920129b25f99dd8d04271/pandas-2.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c4fc4c21971a1a9f4bdb4c73978c7f7256caa3e62b323f70d6cb80db583350bc", size = 13199233, upload_time = "2025-09-29T23:24:24.876Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/04/fd/74903979833db8390b73b3a8a7d30d146d710bd32703724dd9083950386f/pandas-2.3.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:ee15f284898e7b246df8087fc82b87b01686f98ee67d85a17b7ab44143a3a9a0", size = 11540635, upload_time = "2025-09-29T23:25:52.486Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/21/00/266d6b357ad5e6d3ad55093a7e8efc7dd245f5a842b584db9f30b0f0a287/pandas-2.3.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1611aedd912e1ff81ff41c745822980c49ce4a7907537be8692c8dbc31924593", size = 10759079, upload_time = "2025-09-29T23:26:33.204Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ca/05/d01ef80a7a3a12b2f8bbf16daba1e17c98a2f039cbc8e2f77a2c5a63d382/pandas-2.3.3-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6d2cefc361461662ac48810cb14365a365ce864afe85ef1f447ff5a1e99ea81c", size = 11814049, upload_time = "2025-09-29T23:27:15.384Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/15/b2/0e62f78c0c5ba7e3d2c5945a82456f4fac76c480940f805e0b97fcbc2f65/pandas-2.3.3-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ee67acbbf05014ea6c763beb097e03cd629961c8a632075eeb34247120abcb4b", size = 12332638, upload_time = "2025-09-29T23:27:51.625Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c5/33/dd70400631b62b9b29c3c93d2feee1d0964dc2bae2e5ad7a6c73a7f25325/pandas-2.3.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c46467899aaa4da076d5abc11084634e2d197e9460643dd455ac3db5856b24d6", size = 12886834, upload_time = "2025-09-29T23:28:21.289Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d3/18/b5d48f55821228d0d2692b34fd5034bb185e854bdb592e9c640f6290e012/pandas-2.3.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6253c72c6a1d990a410bc7de641d34053364ef8bcd3126f7e7450125887dffe3", size = 13409925, upload_time = "2025-09-29T23:28:58.261Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a6/3d/124ac75fcd0ecc09b8fdccb0246ef65e35b012030defb0e0eba2cbbbe948/pandas-2.3.3-cp314-cp314-win_amd64.whl", hash = "sha256:1b07204a219b3b7350abaae088f451860223a52cfb8a6c53358e7948735158e5", size = 11109071, upload_time = "2025-09-29T23:32:27.484Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/89/9c/0e21c895c38a157e0faa1fb64587a9226d6dd46452cac4532d80c3c4a244/pandas-2.3.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2462b1a365b6109d275250baaae7b760fd25c726aaca0054649286bcfbb3e8ec", size = 12048504, upload_time = "2025-09-29T23:29:31.47Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d7/82/b69a1c95df796858777b68fbe6a81d37443a33319761d7c652ce77797475/pandas-2.3.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0242fe9a49aa8b4d78a4fa03acb397a58833ef6199e9aa40a95f027bb3a1b6e7", size = 11410702, upload_time = "2025-09-29T23:29:54.591Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f9/88/702bde3ba0a94b8c73a0181e05144b10f13f29ebfc2150c3a79062a8195d/pandas-2.3.3-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a21d830e78df0a515db2b3d2f5570610f5e6bd2e27749770e8bb7b524b89b450", size = 11634535, upload_time = "2025-09-29T23:30:21.003Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a4/1e/1bac1a839d12e6a82ec6cb40cda2edde64a2013a66963293696bbf31fbbb/pandas-2.3.3-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2e3ebdb170b5ef78f19bfb71b0dc5dc58775032361fa188e814959b74d726dd5", size = 12121582, upload_time = "2025-09-29T23:30:43.391Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/44/91/483de934193e12a3b1d6ae7c8645d083ff88dec75f46e827562f1e4b4da6/pandas-2.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:d051c0e065b94b7a3cea50eb1ec32e912cd96dba41647eb24104b6c6c14c5788", size = 12699963, upload_time = "2025-09-29T23:31:10.009Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/70/44/5191d2e4026f86a2a109053e194d3ba7a31a2d10a9c2348368c63ed4e85a/pandas-2.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:3869faf4bd07b3b66a9f462417d0ca3a9df29a9f6abd5d0d0dbab15dac7abe87", size = 13202175, upload_time = "2025-09-29T23:31:59.173Z" }, +] + +[[package]] +name = "peewee" +version = "3.18.3" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6f/60/58e7a307a24044e0e982b99042fcd5a58d0cd928d9c01829574d7553ee8d/peewee-3.18.3.tar.gz", hash = "sha256:62c3d93315b1a909360c4b43c3a573b47557a1ec7a4583a71286df2a28d4b72e", size = 3026296, upload_time = "2025-11-03T16:43:46.678Z" } + +[[package]] +name = "pillow" +version = "12.0.0" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5a/b0/cace85a1b0c9775a9f8f5d5423c8261c858760e2466c79b2dd184638b056/pillow-12.0.0.tar.gz", hash = "sha256:87d4f8125c9988bfbed67af47dd7a953e2fc7b0cc1e7800ec6d2080d490bb353", size = 47008828, upload_time = "2025-10-15T18:24:14.008Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5d/08/26e68b6b5da219c2a2cb7b563af008b53bb8e6b6fcb3fa40715fcdb2523a/pillow-12.0.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:3adfb466bbc544b926d50fe8f4a4e6abd8c6bffd28a26177594e6e9b2b76572b", size = 5289809, upload_time = "2025-10-15T18:21:27.791Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/cb/e9/4e58fb097fb74c7b4758a680aacd558810a417d1edaa7000142976ef9d2f/pillow-12.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:1ac11e8ea4f611c3c0147424eae514028b5e9077dd99ab91e1bd7bc33ff145e1", size = 4650606, upload_time = "2025-10-15T18:21:29.823Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/4b/e0/1fa492aa9f77b3bc6d471c468e62bfea1823056bf7e5e4f1914d7ab2565e/pillow-12.0.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d49e2314c373f4c2b39446fb1a45ed333c850e09d0c59ac79b72eb3b95397363", size = 6221023, upload_time = "2025-10-15T18:21:31.415Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c1/09/4de7cd03e33734ccd0c876f0251401f1314e819cbfd89a0fcb6e77927cc6/pillow-12.0.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c7b2a63fd6d5246349f3d3f37b14430d73ee7e8173154461785e43036ffa96ca", size = 8024937, upload_time = "2025-10-15T18:21:33.453Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2e/69/0688e7c1390666592876d9d474f5e135abb4acb39dcb583c4dc5490f1aff/pillow-12.0.0-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d64317d2587c70324b79861babb9c09f71fbb780bad212018874b2c013d8600e", size = 6334139, upload_time = "2025-10-15T18:21:35.395Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ed/1c/880921e98f525b9b44ce747ad1ea8f73fd7e992bafe3ca5e5644bf433dea/pillow-12.0.0-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d77153e14b709fd8b8af6f66a3afbb9ed6e9fc5ccf0b6b7e1ced7b036a228782", size = 7026074, upload_time = "2025-10-15T18:21:37.219Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/28/03/96f718331b19b355610ef4ebdbbde3557c726513030665071fd025745671/pillow-12.0.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:32ed80ea8a90ee3e6fa08c21e2e091bba6eda8eccc83dbc34c95169507a91f10", size = 6448852, upload_time = "2025-10-15T18:21:39.168Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3a/a0/6a193b3f0cc9437b122978d2c5cbce59510ccf9a5b48825096ed7472da2f/pillow-12.0.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:c828a1ae702fc712978bda0320ba1b9893d99be0badf2647f693cc01cf0f04fa", size = 7117058, upload_time = "2025-10-15T18:21:40.997Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a7/c4/043192375eaa4463254e8e61f0e2ec9a846b983929a8d0a7122e0a6d6fff/pillow-12.0.0-cp310-cp310-win32.whl", hash = "sha256:bd87e140e45399c818fac4247880b9ce719e4783d767e030a883a970be632275", size = 6295431, upload_time = "2025-10-15T18:21:42.518Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/92/c6/c2f2fc7e56301c21827e689bb8b0b465f1b52878b57471a070678c0c33cd/pillow-12.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:455247ac8a4cfb7b9bc45b7e432d10421aea9fc2e74d285ba4072688a74c2e9d", size = 7000412, upload_time = "2025-10-15T18:21:44.404Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b2/d2/5f675067ba82da7a1c238a73b32e3fd78d67f9d9f80fbadd33a40b9c0481/pillow-12.0.0-cp310-cp310-win_arm64.whl", hash = "sha256:6ace95230bfb7cd79ef66caa064bbe2f2a1e63d93471c3a2e1f1348d9f22d6b7", size = 2435903, upload_time = "2025-10-15T18:21:46.29Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0e/5a/a2f6773b64edb921a756eb0729068acad9fc5208a53f4a349396e9436721/pillow-12.0.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:0fd00cac9c03256c8b2ff58f162ebcd2587ad3e1f2e397eab718c47e24d231cc", size = 5289798, upload_time = "2025-10-15T18:21:47.763Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2e/05/069b1f8a2e4b5a37493da6c5868531c3f77b85e716ad7a590ef87d58730d/pillow-12.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a3475b96f5908b3b16c47533daaa87380c491357d197564e0ba34ae75c0f3257", size = 4650589, upload_time = "2025-10-15T18:21:49.515Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/61/e3/2c820d6e9a36432503ead175ae294f96861b07600a7156154a086ba7111a/pillow-12.0.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:110486b79f2d112cf6add83b28b627e369219388f64ef2f960fef9ebaf54c642", size = 6230472, upload_time = "2025-10-15T18:21:51.052Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/4f/89/63427f51c64209c5e23d4d52071c8d0f21024d3a8a487737caaf614a5795/pillow-12.0.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5269cc1caeedb67e6f7269a42014f381f45e2e7cd42d834ede3c703a1d915fe3", size = 8033887, upload_time = "2025-10-15T18:21:52.604Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f6/1b/c9711318d4901093c15840f268ad649459cd81984c9ec9887756cca049a5/pillow-12.0.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aa5129de4e174daccbc59d0a3b6d20eaf24417d59851c07ebb37aeb02947987c", size = 6343964, upload_time = "2025-10-15T18:21:54.619Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/41/1e/db9470f2d030b4995083044cd8738cdd1bf773106819f6d8ba12597d5352/pillow-12.0.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bee2a6db3a7242ea309aa7ee8e2780726fed67ff4e5b40169f2c940e7eb09227", size = 7034756, upload_time = "2025-10-15T18:21:56.151Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/cc/b0/6177a8bdd5ee4ed87cba2de5a3cc1db55ffbbec6176784ce5bb75aa96798/pillow-12.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:90387104ee8400a7b4598253b4c406f8958f59fcf983a6cea2b50d59f7d63d0b", size = 6458075, upload_time = "2025-10-15T18:21:57.759Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/bc/5e/61537aa6fa977922c6a03253a0e727e6e4a72381a80d63ad8eec350684f2/pillow-12.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bc91a56697869546d1b8f0a3ff35224557ae7f881050e99f615e0119bf934b4e", size = 7125955, upload_time = "2025-10-15T18:21:59.372Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/1f/3d/d5033539344ee3cbd9a4d69e12e63ca3a44a739eb2d4c8da350a3d38edd7/pillow-12.0.0-cp311-cp311-win32.whl", hash = "sha256:27f95b12453d165099c84f8a8bfdfd46b9e4bda9e0e4b65f0635430027f55739", size = 6298440, upload_time = "2025-10-15T18:22:00.982Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/4d/42/aaca386de5cc8bd8a0254516957c1f265e3521c91515b16e286c662854c4/pillow-12.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:b583dc9070312190192631373c6c8ed277254aa6e6084b74bdd0a6d3b221608e", size = 6999256, upload_time = "2025-10-15T18:22:02.617Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ba/f1/9197c9c2d5708b785f631a6dfbfa8eb3fb9672837cb92ae9af812c13b4ed/pillow-12.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:759de84a33be3b178a64c8ba28ad5c135900359e85fb662bc6e403ad4407791d", size = 2436025, upload_time = "2025-10-15T18:22:04.598Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2c/90/4fcce2c22caf044e660a198d740e7fbc14395619e3cb1abad12192c0826c/pillow-12.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:53561a4ddc36facb432fae7a9d8afbfaf94795414f5cdc5fc52f28c1dca90371", size = 5249377, upload_time = "2025-10-15T18:22:05.993Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fd/e0/ed960067543d080691d47d6938ebccbf3976a931c9567ab2fbfab983a5dd/pillow-12.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:71db6b4c1653045dacc1585c1b0d184004f0d7e694c7b34ac165ca70c0838082", size = 4650343, upload_time = "2025-10-15T18:22:07.718Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e7/a1/f81fdeddcb99c044bf7d6faa47e12850f13cee0849537a7d27eeab5534d4/pillow-12.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2fa5f0b6716fc88f11380b88b31fe591a06c6315e955c096c35715788b339e3f", size = 6232981, upload_time = "2025-10-15T18:22:09.287Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/88/e1/9098d3ce341a8750b55b0e00c03f1630d6178f38ac191c81c97a3b047b44/pillow-12.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:82240051c6ca513c616f7f9da06e871f61bfd7805f566275841af15015b8f98d", size = 8041399, upload_time = "2025-10-15T18:22:10.872Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a7/62/a22e8d3b602ae8cc01446d0c57a54e982737f44b6f2e1e019a925143771d/pillow-12.0.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:55f818bd74fe2f11d4d7cbc65880a843c4075e0ac7226bc1a23261dbea531953", size = 6347740, upload_time = "2025-10-15T18:22:12.769Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/4f/87/424511bdcd02c8d7acf9f65caa09f291a519b16bd83c3fb3374b3d4ae951/pillow-12.0.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b87843e225e74576437fd5b6a4c2205d422754f84a06942cfaf1dc32243e45a8", size = 7040201, upload_time = "2025-10-15T18:22:14.813Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/dc/4d/435c8ac688c54d11755aedfdd9f29c9eeddf68d150fe42d1d3dbd2365149/pillow-12.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c607c90ba67533e1b2355b821fef6764d1dd2cbe26b8c1005ae84f7aea25ff79", size = 6462334, upload_time = "2025-10-15T18:22:16.375Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2b/f2/ad34167a8059a59b8ad10bc5c72d4d9b35acc6b7c0877af8ac885b5f2044/pillow-12.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:21f241bdd5080a15bc86d3466a9f6074a9c2c2b314100dd896ac81ee6db2f1ba", size = 7134162, upload_time = "2025-10-15T18:22:17.996Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0c/b1/a7391df6adacf0a5c2cf6ac1cf1fcc1369e7d439d28f637a847f8803beb3/pillow-12.0.0-cp312-cp312-win32.whl", hash = "sha256:dd333073e0cacdc3089525c7df7d39b211bcdf31fc2824e49d01c6b6187b07d0", size = 6298769, upload_time = "2025-10-15T18:22:19.923Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a2/0b/d87733741526541c909bbf159e338dcace4f982daac6e5a8d6be225ca32d/pillow-12.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:9fe611163f6303d1619bbcb653540a4d60f9e55e622d60a3108be0d5b441017a", size = 7001107, upload_time = "2025-10-15T18:22:21.644Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/bc/96/aaa61ce33cc98421fb6088af2a03be4157b1e7e0e87087c888e2370a7f45/pillow-12.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:7dfb439562f234f7d57b1ac6bc8fe7f838a4bd49c79230e0f6a1da93e82f1fad", size = 2436012, upload_time = "2025-10-15T18:22:23.621Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/62/f2/de993bb2d21b33a98d031ecf6a978e4b61da207bef02f7b43093774c480d/pillow-12.0.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:0869154a2d0546545cde61d1789a6524319fc1897d9ee31218eae7a60ccc5643", size = 4045493, upload_time = "2025-10-15T18:22:25.758Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0e/b6/bc8d0c4c9f6f111a783d045310945deb769b806d7574764234ffd50bc5ea/pillow-12.0.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:a7921c5a6d31b3d756ec980f2f47c0cfdbce0fc48c22a39347a895f41f4a6ea4", size = 4120461, upload_time = "2025-10-15T18:22:27.286Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5d/57/d60d343709366a353dc56adb4ee1e7d8a2cc34e3fbc22905f4167cfec119/pillow-12.0.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:1ee80a59f6ce048ae13cda1abf7fbd2a34ab9ee7d401c46be3ca685d1999a399", size = 3576912, upload_time = "2025-10-15T18:22:28.751Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a4/a4/a0a31467e3f83b94d37568294b01d22b43ae3c5d85f2811769b9c66389dd/pillow-12.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c50f36a62a22d350c96e49ad02d0da41dbd17ddc2e29750dbdba4323f85eb4a5", size = 5249132, upload_time = "2025-10-15T18:22:30.641Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/83/06/48eab21dd561de2914242711434c0c0eb992ed08ff3f6107a5f44527f5e9/pillow-12.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5193fde9a5f23c331ea26d0cf171fbf67e3f247585f50c08b3e205c7aeb4589b", size = 4650099, upload_time = "2025-10-15T18:22:32.73Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fc/bd/69ed99fd46a8dba7c1887156d3572fe4484e3f031405fcc5a92e31c04035/pillow-12.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:bde737cff1a975b70652b62d626f7785e0480918dece11e8fef3c0cf057351c3", size = 6230808, upload_time = "2025-10-15T18:22:34.337Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ea/94/8fad659bcdbf86ed70099cb60ae40be6acca434bbc8c4c0d4ef356d7e0de/pillow-12.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a6597ff2b61d121172f5844b53f21467f7082f5fb385a9a29c01414463f93b07", size = 8037804, upload_time = "2025-10-15T18:22:36.402Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/20/39/c685d05c06deecfd4e2d1950e9a908aa2ca8bc4e6c3b12d93b9cafbd7837/pillow-12.0.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0b817e7035ea7f6b942c13aa03bb554fc44fea70838ea21f8eb31c638326584e", size = 6345553, upload_time = "2025-10-15T18:22:38.066Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/38/57/755dbd06530a27a5ed74f8cb0a7a44a21722ebf318edbe67ddbd7fb28f88/pillow-12.0.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f4f1231b7dec408e8670264ce63e9c71409d9583dd21d32c163e25213ee2a344", size = 7037729, upload_time = "2025-10-15T18:22:39.769Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ca/b6/7e94f4c41d238615674d06ed677c14883103dce1c52e4af16f000338cfd7/pillow-12.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6e51b71417049ad6ab14c49608b4a24d8fb3fe605e5dfabfe523b58064dc3d27", size = 6459789, upload_time = "2025-10-15T18:22:41.437Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/9c/14/4448bb0b5e0f22dd865290536d20ec8a23b64e2d04280b89139f09a36bb6/pillow-12.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d120c38a42c234dc9a8c5de7ceaaf899cf33561956acb4941653f8bdc657aa79", size = 7130917, upload_time = "2025-10-15T18:22:43.152Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/dd/ca/16c6926cc1c015845745d5c16c9358e24282f1e588237a4c36d2b30f182f/pillow-12.0.0-cp313-cp313-win32.whl", hash = "sha256:4cc6b3b2efff105c6a1656cfe59da4fdde2cda9af1c5e0b58529b24525d0a098", size = 6302391, upload_time = "2025-10-15T18:22:44.753Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6d/2a/dd43dcfd6dae9b6a49ee28a8eedb98c7d5ff2de94a5d834565164667b97b/pillow-12.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:4cf7fed4b4580601c4345ceb5d4cbf5a980d030fd5ad07c4d2ec589f95f09905", size = 7007477, upload_time = "2025-10-15T18:22:46.838Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/77/f0/72ea067f4b5ae5ead653053212af05ce3705807906ba3f3e8f58ddf617e6/pillow-12.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:9f0b04c6b8584c2c193babcccc908b38ed29524b29dd464bc8801bf10d746a3a", size = 2435918, upload_time = "2025-10-15T18:22:48.399Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f5/5e/9046b423735c21f0487ea6cb5b10f89ea8f8dfbe32576fe052b5ba9d4e5b/pillow-12.0.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:7fa22993bac7b77b78cae22bad1e2a987ddf0d9015c63358032f84a53f23cdc3", size = 5251406, upload_time = "2025-10-15T18:22:49.905Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/12/66/982ceebcdb13c97270ef7a56c3969635b4ee7cd45227fa707c94719229c5/pillow-12.0.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:f135c702ac42262573fe9714dfe99c944b4ba307af5eb507abef1667e2cbbced", size = 4653218, upload_time = "2025-10-15T18:22:51.587Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/16/b3/81e625524688c31859450119bf12674619429cab3119eec0e30a7a1029cb/pillow-12.0.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c85de1136429c524e55cfa4e033b4a7940ac5c8ee4d9401cc2d1bf48154bbc7b", size = 6266564, upload_time = "2025-10-15T18:22:53.215Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/98/59/dfb38f2a41240d2408096e1a76c671d0a105a4a8471b1871c6902719450c/pillow-12.0.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:38df9b4bfd3db902c9c2bd369bcacaf9d935b2fff73709429d95cc41554f7b3d", size = 8069260, upload_time = "2025-10-15T18:22:54.933Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/dc/3d/378dbea5cd1874b94c312425ca77b0f47776c78e0df2df751b820c8c1d6c/pillow-12.0.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7d87ef5795da03d742bf49439f9ca4d027cde49c82c5371ba52464aee266699a", size = 6379248, upload_time = "2025-10-15T18:22:56.605Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/84/b0/d525ef47d71590f1621510327acec75ae58c721dc071b17d8d652ca494d8/pillow-12.0.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:aff9e4d82d082ff9513bdd6acd4f5bd359f5b2c870907d2b0a9c5e10d40c88fe", size = 7066043, upload_time = "2025-10-15T18:22:58.53Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/61/2c/aced60e9cf9d0cde341d54bf7932c9ffc33ddb4a1595798b3a5150c7ec4e/pillow-12.0.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:8d8ca2b210ada074d57fcee40c30446c9562e542fc46aedc19baf758a93532ee", size = 6490915, upload_time = "2025-10-15T18:23:00.582Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ef/26/69dcb9b91f4e59f8f34b2332a4a0a951b44f547c4ed39d3e4dcfcff48f89/pillow-12.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:99a7f72fb6249302aa62245680754862a44179b545ded638cf1fef59befb57ef", size = 7157998, upload_time = "2025-10-15T18:23:02.627Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/61/2b/726235842220ca95fa441ddf55dd2382b52ab5b8d9c0596fe6b3f23dafe8/pillow-12.0.0-cp313-cp313t-win32.whl", hash = "sha256:4078242472387600b2ce8d93ade8899c12bf33fa89e55ec89fe126e9d6d5d9e9", size = 6306201, upload_time = "2025-10-15T18:23:04.709Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c0/3d/2afaf4e840b2df71344ababf2f8edd75a705ce500e5dc1e7227808312ae1/pillow-12.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:2c54c1a783d6d60595d3514f0efe9b37c8808746a66920315bfd34a938d7994b", size = 7013165, upload_time = "2025-10-15T18:23:06.46Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6f/75/3fa09aa5cf6ed04bee3fa575798ddf1ce0bace8edb47249c798077a81f7f/pillow-12.0.0-cp313-cp313t-win_arm64.whl", hash = "sha256:26d9f7d2b604cd23aba3e9faf795787456ac25634d82cd060556998e39c6fa47", size = 2437834, upload_time = "2025-10-15T18:23:08.194Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/54/2a/9a8c6ba2c2c07b71bec92cf63e03370ca5e5f5c5b119b742bcc0cde3f9c5/pillow-12.0.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:beeae3f27f62308f1ddbcfb0690bf44b10732f2ef43758f169d5e9303165d3f9", size = 4045531, upload_time = "2025-10-15T18:23:10.121Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/84/54/836fdbf1bfb3d66a59f0189ff0b9f5f666cee09c6188309300df04ad71fa/pillow-12.0.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:d4827615da15cd59784ce39d3388275ec093ae3ee8d7f0c089b76fa87af756c2", size = 4120554, upload_time = "2025-10-15T18:23:12.14Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0d/cd/16aec9f0da4793e98e6b54778a5fbce4f375c6646fe662e80600b8797379/pillow-12.0.0-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:3e42edad50b6909089750e65c91aa09aaf1e0a71310d383f11321b27c224ed8a", size = 3576812, upload_time = "2025-10-15T18:23:13.962Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f6/b7/13957fda356dc46339298b351cae0d327704986337c3c69bb54628c88155/pillow-12.0.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:e5d8efac84c9afcb40914ab49ba063d94f5dbdf5066db4482c66a992f47a3a3b", size = 5252689, upload_time = "2025-10-15T18:23:15.562Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fc/f5/eae31a306341d8f331f43edb2e9122c7661b975433de5e447939ae61c5da/pillow-12.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:266cd5f2b63ff316d5a1bba46268e603c9caf5606d44f38c2873c380950576ad", size = 4650186, upload_time = "2025-10-15T18:23:17.379Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/86/62/2a88339aa40c4c77e79108facbd307d6091e2c0eb5b8d3cf4977cfca2fe6/pillow-12.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:58eea5ebe51504057dd95c5b77d21700b77615ab0243d8152793dc00eb4faf01", size = 6230308, upload_time = "2025-10-15T18:23:18.971Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c7/33/5425a8992bcb32d1cb9fa3dd39a89e613d09a22f2c8083b7bf43c455f760/pillow-12.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f13711b1a5ba512d647a0e4ba79280d3a9a045aaf7e0cc6fbe96b91d4cdf6b0c", size = 8039222, upload_time = "2025-10-15T18:23:20.909Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d8/61/3f5d3b35c5728f37953d3eec5b5f3e77111949523bd2dd7f31a851e50690/pillow-12.0.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6846bd2d116ff42cba6b646edf5bf61d37e5cbd256425fa089fee4ff5c07a99e", size = 6346657, upload_time = "2025-10-15T18:23:23.077Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3a/be/ee90a3d79271227e0f0a33c453531efd6ed14b2e708596ba5dd9be948da3/pillow-12.0.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c98fa880d695de164b4135a52fd2e9cd7b7c90a9d8ac5e9e443a24a95ef9248e", size = 7038482, upload_time = "2025-10-15T18:23:25.005Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/44/34/a16b6a4d1ad727de390e9bd9f19f5f669e079e5826ec0f329010ddea492f/pillow-12.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fa3ed2a29a9e9d2d488b4da81dcb54720ac3104a20bf0bd273f1e4648aff5af9", size = 6461416, upload_time = "2025-10-15T18:23:27.009Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b6/39/1aa5850d2ade7d7ba9f54e4e4c17077244ff7a2d9e25998c38a29749eb3f/pillow-12.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d034140032870024e6b9892c692fe2968493790dd57208b2c37e3fb35f6df3ab", size = 7131584, upload_time = "2025-10-15T18:23:29.752Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/bf/db/4fae862f8fad0167073a7733973bfa955f47e2cac3dc3e3e6257d10fab4a/pillow-12.0.0-cp314-cp314-win32.whl", hash = "sha256:1b1b133e6e16105f524a8dec491e0586d072948ce15c9b914e41cdadd209052b", size = 6400621, upload_time = "2025-10-15T18:23:32.06Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2b/24/b350c31543fb0107ab2599464d7e28e6f856027aadda995022e695313d94/pillow-12.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:8dc232e39d409036af549c86f24aed8273a40ffa459981146829a324e0848b4b", size = 7142916, upload_time = "2025-10-15T18:23:34.71Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0f/9b/0ba5a6fd9351793996ef7487c4fdbde8d3f5f75dbedc093bb598648fddf0/pillow-12.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:d52610d51e265a51518692045e372a4c363056130d922a7351429ac9f27e70b0", size = 2523836, upload_time = "2025-10-15T18:23:36.967Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f5/7a/ceee0840aebc579af529b523d530840338ecf63992395842e54edc805987/pillow-12.0.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:1979f4566bb96c1e50a62d9831e2ea2d1211761e5662afc545fa766f996632f6", size = 5255092, upload_time = "2025-10-15T18:23:38.573Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/44/76/20776057b4bfd1aef4eeca992ebde0f53a4dce874f3ae693d0ec90a4f79b/pillow-12.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b2e4b27a6e15b04832fe9bf292b94b5ca156016bbc1ea9c2c20098a0320d6cf6", size = 4653158, upload_time = "2025-10-15T18:23:40.238Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/82/3f/d9ff92ace07be8836b4e7e87e6a4c7a8318d47c2f1463ffcf121fc57d9cb/pillow-12.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:fb3096c30df99fd01c7bf8e544f392103d0795b9f98ba71a8054bcbf56b255f1", size = 6267882, upload_time = "2025-10-15T18:23:42.434Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/9f/7a/4f7ff87f00d3ad33ba21af78bfcd2f032107710baf8280e3722ceec28cda/pillow-12.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7438839e9e053ef79f7112c881cef684013855016f928b168b81ed5835f3e75e", size = 8071001, upload_time = "2025-10-15T18:23:44.29Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/75/87/fcea108944a52dad8cca0715ae6247e271eb80459364a98518f1e4f480c1/pillow-12.0.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5d5c411a8eaa2299322b647cd932586b1427367fd3184ffbb8f7a219ea2041ca", size = 6380146, upload_time = "2025-10-15T18:23:46.065Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/91/52/0d31b5e571ef5fd111d2978b84603fce26aba1b6092f28e941cb46570745/pillow-12.0.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d7e091d464ac59d2c7ad8e7e08105eaf9dafbc3883fd7265ffccc2baad6ac925", size = 7067344, upload_time = "2025-10-15T18:23:47.898Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/7b/f4/2dd3d721f875f928d48e83bb30a434dee75a2531bca839bb996bb0aa5a91/pillow-12.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:792a2c0be4dcc18af9d4a2dfd8a11a17d5e25274a1062b0ec1c2d79c76f3e7f8", size = 6491864, upload_time = "2025-10-15T18:23:49.607Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/30/4b/667dfcf3d61fc309ba5a15b141845cece5915e39b99c1ceab0f34bf1d124/pillow-12.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:afbefa430092f71a9593a99ab6a4e7538bc9eabbf7bf94f91510d3503943edc4", size = 7158911, upload_time = "2025-10-15T18:23:51.351Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a2/2f/16cabcc6426c32218ace36bf0d55955e813f2958afddbf1d391849fee9d1/pillow-12.0.0-cp314-cp314t-win32.whl", hash = "sha256:3830c769decf88f1289680a59d4f4c46c72573446352e2befec9a8512104fa52", size = 6408045, upload_time = "2025-10-15T18:23:53.177Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/35/73/e29aa0c9c666cf787628d3f0dcf379f4791fba79f4936d02f8b37165bdf8/pillow-12.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:905b0365b210c73afb0ebe9101a32572152dfd1c144c7e28968a331b9217b94a", size = 7148282, upload_time = "2025-10-15T18:23:55.316Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c1/70/6b41bdcddf541b437bbb9f47f94d2db5d9ddef6c37ccab8c9107743748a4/pillow-12.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:99353a06902c2e43b43e8ff74ee65a7d90307d82370604746738a1e0661ccca7", size = 2525630, upload_time = "2025-10-15T18:23:57.149Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/1d/b3/582327e6c9f86d037b63beebe981425d6811104cb443e8193824ef1a2f27/pillow-12.0.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:b22bd8c974942477156be55a768f7aa37c46904c175be4e158b6a86e3a6b7ca8", size = 5215068, upload_time = "2025-10-15T18:23:59.594Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fd/d6/67748211d119f3b6540baf90f92fae73ae51d5217b171b0e8b5f7e5d558f/pillow-12.0.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:805ebf596939e48dbb2e4922a1d3852cfc25c38160751ce02da93058b48d252a", size = 4614994, upload_time = "2025-10-15T18:24:01.669Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2d/e1/f8281e5d844c41872b273b9f2c34a4bf64ca08905668c8ae730eedc7c9fa/pillow-12.0.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cae81479f77420d217def5f54b5b9d279804d17e982e0f2fa19b1d1e14ab5197", size = 5246639, upload_time = "2025-10-15T18:24:03.403Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/94/5a/0d8ab8ffe8a102ff5df60d0de5af309015163bf710c7bb3e8311dd3b3ad0/pillow-12.0.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:aeaefa96c768fc66818730b952a862235d68825c178f1b3ffd4efd7ad2edcb7c", size = 6986839, upload_time = "2025-10-15T18:24:05.344Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/20/2e/3434380e8110b76cd9eb00a363c484b050f949b4bbe84ba770bb8508a02c/pillow-12.0.0-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:09f2d0abef9e4e2f349305a4f8cc784a8a6c2f58a8c4892eea13b10a943bd26e", size = 5313505, upload_time = "2025-10-15T18:24:07.137Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/57/ca/5a9d38900d9d74785141d6580950fe705de68af735ff6e727cb911b64740/pillow-12.0.0-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bdee52571a343d721fb2eb3b090a82d959ff37fc631e3f70422e0c2e029f3e76", size = 5963654, upload_time = "2025-10-15T18:24:09.579Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/95/7e/f896623c3c635a90537ac093c6a618ebe1a90d87206e42309cb5d98a1b9e/pillow-12.0.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:b290fd8aa38422444d4b50d579de197557f182ef1068b75f5aa8558638b8d0a5", size = 6997850, upload_time = "2025-10-15T18:24:11.495Z" }, +] + +[[package]] +name = "propcache" +version = "0.4.1" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/9e/da/e9fc233cf63743258bff22b3dfa7ea5baef7b5bc324af47a0ad89b8ffc6f/propcache-0.4.1.tar.gz", hash = "sha256:f48107a8c637e80362555f37ecf49abe20370e557cc4ab374f04ec4423c97c3d", size = 46442, upload_time = "2025-10-08T19:49:02.291Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3c/0e/934b541323035566a9af292dba85a195f7b78179114f2c6ebb24551118a9/propcache-0.4.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7c2d1fa3201efaf55d730400d945b5b3ab6e672e100ba0f9a409d950ab25d7db", size = 79534, upload_time = "2025-10-08T19:46:02.083Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a1/6b/db0d03d96726d995dc7171286c6ba9d8d14251f37433890f88368951a44e/propcache-0.4.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:1eb2994229cc8ce7fe9b3db88f5465f5fd8651672840b2e426b88cdb1a30aac8", size = 45526, upload_time = "2025-10-08T19:46:03.884Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e4/c3/82728404aea669e1600f304f2609cde9e665c18df5a11cdd57ed73c1dceb/propcache-0.4.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:66c1f011f45a3b33d7bcb22daed4b29c0c9e2224758b6be00686731e1b46f925", size = 47263, upload_time = "2025-10-08T19:46:05.405Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/df/1b/39313ddad2bf9187a1432654c38249bab4562ef535ef07f5eb6eb04d0b1b/propcache-0.4.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9a52009f2adffe195d0b605c25ec929d26b36ef986ba85244891dee3b294df21", size = 201012, upload_time = "2025-10-08T19:46:07.165Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5b/01/f1d0b57d136f294a142acf97f4ed58c8e5b974c21e543000968357115011/propcache-0.4.1-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5d4e2366a9c7b837555cf02fb9be2e3167d333aff716332ef1b7c3a142ec40c5", size = 209491, upload_time = "2025-10-08T19:46:08.909Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a1/c8/038d909c61c5bb039070b3fb02ad5cccdb1dde0d714792e251cdb17c9c05/propcache-0.4.1-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:9d2b6caef873b4f09e26ea7e33d65f42b944837563a47a94719cc3544319a0db", size = 215319, upload_time = "2025-10-08T19:46:10.7Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/08/57/8c87e93142b2c1fa2408e45695205a7ba05fb5db458c0bf5c06ba0e09ea6/propcache-0.4.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2b16ec437a8c8a965ecf95739448dd938b5c7f56e67ea009f4300d8df05f32b7", size = 196856, upload_time = "2025-10-08T19:46:12.003Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/42/df/5615fec76aa561987a534759b3686008a288e73107faa49a8ae5795a9f7a/propcache-0.4.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:296f4c8ed03ca7476813fe666c9ea97869a8d7aec972618671b33a38a5182ef4", size = 193241, upload_time = "2025-10-08T19:46:13.495Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d5/21/62949eb3a7a54afe8327011c90aca7e03547787a88fb8bd9726806482fea/propcache-0.4.1-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:1f0978529a418ebd1f49dad413a2b68af33f85d5c5ca5c6ca2a3bed375a7ac60", size = 190552, upload_time = "2025-10-08T19:46:14.938Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/30/ee/ab4d727dd70806e5b4de96a798ae7ac6e4d42516f030ee60522474b6b332/propcache-0.4.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:fd138803047fb4c062b1c1dd95462f5209456bfab55c734458f15d11da288f8f", size = 200113, upload_time = "2025-10-08T19:46:16.695Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8a/0b/38b46208e6711b016aa8966a3ac793eee0d05c7159d8342aa27fc0bc365e/propcache-0.4.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:8c9b3cbe4584636d72ff556d9036e0c9317fa27b3ac1f0f558e7e84d1c9c5900", size = 200778, upload_time = "2025-10-08T19:46:18.023Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/cf/81/5abec54355ed344476bee711e9f04815d4b00a311ab0535599204eecc257/propcache-0.4.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f93243fdc5657247533273ac4f86ae106cc6445a0efacb9a1bfe982fcfefd90c", size = 193047, upload_time = "2025-10-08T19:46:19.449Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ec/b6/1f237c04e32063cb034acd5f6ef34ef3a394f75502e72703545631ab1ef6/propcache-0.4.1-cp310-cp310-win32.whl", hash = "sha256:a0ee98db9c5f80785b266eb805016e36058ac72c51a064040f2bc43b61101cdb", size = 38093, upload_time = "2025-10-08T19:46:20.643Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a6/67/354aac4e0603a15f76439caf0427781bcd6797f370377f75a642133bc954/propcache-0.4.1-cp310-cp310-win_amd64.whl", hash = "sha256:1cdb7988c4e5ac7f6d175a28a9aa0c94cb6f2ebe52756a3c0cda98d2809a9e37", size = 41638, upload_time = "2025-10-08T19:46:21.935Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e0/e1/74e55b9fd1a4c209ff1a9a824bf6c8b3d1fc5a1ac3eabe23462637466785/propcache-0.4.1-cp310-cp310-win_arm64.whl", hash = "sha256:d82ad62b19645419fe79dd63b3f9253e15b30e955c0170e5cebc350c1844e581", size = 38229, upload_time = "2025-10-08T19:46:23.368Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8c/d4/4e2c9aaf7ac2242b9358f98dccd8f90f2605402f5afeff6c578682c2c491/propcache-0.4.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:60a8fda9644b7dfd5dece8c61d8a85e271cb958075bfc4e01083c148b61a7caf", size = 80208, upload_time = "2025-10-08T19:46:24.597Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c2/21/d7b68e911f9c8e18e4ae43bdbc1e1e9bbd971f8866eb81608947b6f585ff/propcache-0.4.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c30b53e7e6bda1d547cabb47c825f3843a0a1a42b0496087bb58d8fedf9f41b5", size = 45777, upload_time = "2025-10-08T19:46:25.733Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d3/1d/11605e99ac8ea9435651ee71ab4cb4bf03f0949586246476a25aadfec54a/propcache-0.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6918ecbd897443087a3b7cd978d56546a812517dcaaca51b49526720571fa93e", size = 47647, upload_time = "2025-10-08T19:46:27.304Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/58/1a/3c62c127a8466c9c843bccb503d40a273e5cc69838805f322e2826509e0d/propcache-0.4.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3d902a36df4e5989763425a8ab9e98cd8ad5c52c823b34ee7ef307fd50582566", size = 214929, upload_time = "2025-10-08T19:46:28.62Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/56/b9/8fa98f850960b367c4b8fe0592e7fc341daa7a9462e925228f10a60cf74f/propcache-0.4.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a9695397f85973bb40427dedddf70d8dc4a44b22f1650dd4af9eedf443d45165", size = 221778, upload_time = "2025-10-08T19:46:30.358Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/46/a6/0ab4f660eb59649d14b3d3d65c439421cf2f87fe5dd68591cbe3c1e78a89/propcache-0.4.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2bb07ffd7eaad486576430c89f9b215f9e4be68c4866a96e97db9e97fead85dc", size = 228144, upload_time = "2025-10-08T19:46:32.607Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/52/6a/57f43e054fb3d3a56ac9fc532bc684fc6169a26c75c353e65425b3e56eef/propcache-0.4.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fd6f30fdcf9ae2a70abd34da54f18da086160e4d7d9251f81f3da0ff84fc5a48", size = 210030, upload_time = "2025-10-08T19:46:33.969Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/40/e2/27e6feebb5f6b8408fa29f5efbb765cd54c153ac77314d27e457a3e993b7/propcache-0.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:fc38cba02d1acba4e2869eef1a57a43dfbd3d49a59bf90dda7444ec2be6a5570", size = 208252, upload_time = "2025-10-08T19:46:35.309Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/9e/f8/91c27b22ccda1dbc7967f921c42825564fa5336a01ecd72eb78a9f4f53c2/propcache-0.4.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:67fad6162281e80e882fb3ec355398cf72864a54069d060321f6cd0ade95fe85", size = 202064, upload_time = "2025-10-08T19:46:36.993Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f2/26/7f00bd6bd1adba5aafe5f4a66390f243acab58eab24ff1a08bebb2ef9d40/propcache-0.4.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:f10207adf04d08bec185bae14d9606a1444715bc99180f9331c9c02093e1959e", size = 212429, upload_time = "2025-10-08T19:46:38.398Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/84/89/fd108ba7815c1117ddca79c228f3f8a15fc82a73bca8b142eb5de13b2785/propcache-0.4.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:e9b0d8d0845bbc4cfcdcbcdbf5086886bc8157aa963c31c777ceff7846c77757", size = 216727, upload_time = "2025-10-08T19:46:39.732Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/79/37/3ec3f7e3173e73f1d600495d8b545b53802cbf35506e5732dd8578db3724/propcache-0.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:981333cb2f4c1896a12f4ab92a9cc8f09ea664e9b7dbdc4eff74627af3a11c0f", size = 205097, upload_time = "2025-10-08T19:46:41.025Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/61/b0/b2631c19793f869d35f47d5a3a56fb19e9160d3c119f15ac7344fc3ccae7/propcache-0.4.1-cp311-cp311-win32.whl", hash = "sha256:f1d2f90aeec838a52f1c1a32fe9a619fefd5e411721a9117fbf82aea638fe8a1", size = 38084, upload_time = "2025-10-08T19:46:42.693Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f4/78/6cce448e2098e9f3bfc91bb877f06aa24b6ccace872e39c53b2f707c4648/propcache-0.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:364426a62660f3f699949ac8c621aad6977be7126c5807ce48c0aeb8e7333ea6", size = 41637, upload_time = "2025-10-08T19:46:43.778Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/9c/e9/754f180cccd7f51a39913782c74717c581b9cc8177ad0e949f4d51812383/propcache-0.4.1-cp311-cp311-win_arm64.whl", hash = "sha256:e53f3a38d3510c11953f3e6a33f205c6d1b001129f972805ca9b42fc308bc239", size = 38064, upload_time = "2025-10-08T19:46:44.872Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a2/0f/f17b1b2b221d5ca28b4b876e8bb046ac40466513960646bda8e1853cdfa2/propcache-0.4.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e153e9cd40cc8945138822807139367f256f89c6810c2634a4f6902b52d3b4e2", size = 80061, upload_time = "2025-10-08T19:46:46.075Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/76/47/8ccf75935f51448ba9a16a71b783eb7ef6b9ee60f5d14c7f8a8a79fbeed7/propcache-0.4.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:cd547953428f7abb73c5ad82cbb32109566204260d98e41e5dfdc682eb7f8403", size = 46037, upload_time = "2025-10-08T19:46:47.23Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0a/b6/5c9a0e42df4d00bfb4a3cbbe5cf9f54260300c88a0e9af1f47ca5ce17ac0/propcache-0.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f048da1b4f243fc44f205dfd320933a951b8d89e0afd4c7cacc762a8b9165207", size = 47324, upload_time = "2025-10-08T19:46:48.384Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/9e/d3/6c7ee328b39a81ee877c962469f1e795f9db87f925251efeb0545e0020d0/propcache-0.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ec17c65562a827bba85e3872ead335f95405ea1674860d96483a02f5c698fa72", size = 225505, upload_time = "2025-10-08T19:46:50.055Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/01/5d/1c53f4563490b1d06a684742cc6076ef944bc6457df6051b7d1a877c057b/propcache-0.4.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:405aac25c6394ef275dee4c709be43745d36674b223ba4eb7144bf4d691b7367", size = 230242, upload_time = "2025-10-08T19:46:51.815Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/20/e1/ce4620633b0e2422207c3cb774a0ee61cac13abc6217763a7b9e2e3f4a12/propcache-0.4.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0013cb6f8dde4b2a2f66903b8ba740bdfe378c943c4377a200551ceb27f379e4", size = 238474, upload_time = "2025-10-08T19:46:53.208Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/46/4b/3aae6835b8e5f44ea6a68348ad90f78134047b503765087be2f9912140ea/propcache-0.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:15932ab57837c3368b024473a525e25d316d8353016e7cc0e5ba9eb343fbb1cf", size = 221575, upload_time = "2025-10-08T19:46:54.511Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6e/a5/8a5e8678bcc9d3a1a15b9a29165640d64762d424a16af543f00629c87338/propcache-0.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:031dce78b9dc099f4c29785d9cf5577a3faf9ebf74ecbd3c856a7b92768c3df3", size = 216736, upload_time = "2025-10-08T19:46:56.212Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f1/63/b7b215eddeac83ca1c6b934f89d09a625aa9ee4ba158338854c87210cc36/propcache-0.4.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:ab08df6c9a035bee56e31af99be621526bd237bea9f32def431c656b29e41778", size = 213019, upload_time = "2025-10-08T19:46:57.595Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/57/74/f580099a58c8af587cac7ba19ee7cb418506342fbbe2d4a4401661cca886/propcache-0.4.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4d7af63f9f93fe593afbf104c21b3b15868efb2c21d07d8732c0c4287e66b6a6", size = 220376, upload_time = "2025-10-08T19:46:59.067Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c4/ee/542f1313aff7eaf19c2bb758c5d0560d2683dac001a1c96d0774af799843/propcache-0.4.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:cfc27c945f422e8b5071b6e93169679e4eb5bf73bbcbf1ba3ae3a83d2f78ebd9", size = 226988, upload_time = "2025-10-08T19:47:00.544Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8f/18/9c6b015dd9c6930f6ce2229e1f02fb35298b847f2087ea2b436a5bfa7287/propcache-0.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:35c3277624a080cc6ec6f847cbbbb5b49affa3598c4535a0a4682a697aaa5c75", size = 215615, upload_time = "2025-10-08T19:47:01.968Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/80/9e/e7b85720b98c45a45e1fca6a177024934dc9bc5f4d5dd04207f216fc33ed/propcache-0.4.1-cp312-cp312-win32.whl", hash = "sha256:671538c2262dadb5ba6395e26c1731e1d52534bfe9ae56d0b5573ce539266aa8", size = 38066, upload_time = "2025-10-08T19:47:03.503Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/54/09/d19cff2a5aaac632ec8fc03737b223597b1e347416934c1b3a7df079784c/propcache-0.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:cb2d222e72399fcf5890d1d5cc1060857b9b236adff2792ff48ca2dfd46c81db", size = 41655, upload_time = "2025-10-08T19:47:04.973Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/68/ab/6b5c191bb5de08036a8c697b265d4ca76148efb10fa162f14af14fb5f076/propcache-0.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:204483131fb222bdaaeeea9f9e6c6ed0cac32731f75dfc1d4a567fc1926477c1", size = 37789, upload_time = "2025-10-08T19:47:06.077Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/bf/df/6d9c1b6ac12b003837dde8a10231a7344512186e87b36e855bef32241942/propcache-0.4.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:43eedf29202c08550aac1d14e0ee619b0430aaef78f85864c1a892294fbc28cf", size = 77750, upload_time = "2025-10-08T19:47:07.648Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8b/e8/677a0025e8a2acf07d3418a2e7ba529c9c33caf09d3c1f25513023c1db56/propcache-0.4.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d62cdfcfd89ccb8de04e0eda998535c406bf5e060ffd56be6c586cbcc05b3311", size = 44780, upload_time = "2025-10-08T19:47:08.851Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/89/a4/92380f7ca60f99ebae761936bc48a72a639e8a47b29050615eef757cb2a7/propcache-0.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cae65ad55793da34db5f54e4029b89d3b9b9490d8abe1b4c7ab5d4b8ec7ebf74", size = 46308, upload_time = "2025-10-08T19:47:09.982Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2d/48/c5ac64dee5262044348d1d78a5f85dd1a57464a60d30daee946699963eb3/propcache-0.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:333ddb9031d2704a301ee3e506dc46b1fe5f294ec198ed6435ad5b6a085facfe", size = 208182, upload_time = "2025-10-08T19:47:11.319Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c6/0c/cd762dd011a9287389a6a3eb43aa30207bde253610cca06824aeabfe9653/propcache-0.4.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fd0858c20f078a32cf55f7e81473d96dcf3b93fd2ccdb3d40fdf54b8573df3af", size = 211215, upload_time = "2025-10-08T19:47:13.146Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/30/3e/49861e90233ba36890ae0ca4c660e95df565b2cd15d4a68556ab5865974e/propcache-0.4.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:678ae89ebc632c5c204c794f8dab2837c5f159aeb59e6ed0539500400577298c", size = 218112, upload_time = "2025-10-08T19:47:14.913Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f1/8b/544bc867e24e1bd48f3118cecd3b05c694e160a168478fa28770f22fd094/propcache-0.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d472aeb4fbf9865e0c6d622d7f4d54a4e101a89715d8904282bb5f9a2f476c3f", size = 204442, upload_time = "2025-10-08T19:47:16.277Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/50/a6/4282772fd016a76d3e5c0df58380a5ea64900afd836cec2c2f662d1b9bb3/propcache-0.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4d3df5fa7e36b3225954fba85589da77a0fe6a53e3976de39caf04a0db4c36f1", size = 199398, upload_time = "2025-10-08T19:47:17.962Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3e/ec/d8a7cd406ee1ddb705db2139f8a10a8a427100347bd698e7014351c7af09/propcache-0.4.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:ee17f18d2498f2673e432faaa71698032b0127ebf23ae5974eeaf806c279df24", size = 196920, upload_time = "2025-10-08T19:47:19.355Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f6/6c/f38ab64af3764f431e359f8baf9e0a21013e24329e8b85d2da32e8ed07ca/propcache-0.4.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:580e97762b950f993ae618e167e7be9256b8353c2dcd8b99ec100eb50f5286aa", size = 203748, upload_time = "2025-10-08T19:47:21.338Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d6/e3/fa846bd70f6534d647886621388f0a265254d30e3ce47e5c8e6e27dbf153/propcache-0.4.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:501d20b891688eb8e7aa903021f0b72d5a55db40ffaab27edefd1027caaafa61", size = 205877, upload_time = "2025-10-08T19:47:23.059Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e2/39/8163fc6f3133fea7b5f2827e8eba2029a0277ab2c5beee6c1db7b10fc23d/propcache-0.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a0bd56e5b100aef69bd8562b74b46254e7c8812918d3baa700c8a8009b0af66", size = 199437, upload_time = "2025-10-08T19:47:24.445Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/93/89/caa9089970ca49c7c01662bd0eeedfe85494e863e8043565aeb6472ce8fe/propcache-0.4.1-cp313-cp313-win32.whl", hash = "sha256:bcc9aaa5d80322bc2fb24bb7accb4a30f81e90ab8d6ba187aec0744bc302ad81", size = 37586, upload_time = "2025-10-08T19:47:25.736Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f5/ab/f76ec3c3627c883215b5c8080debb4394ef5a7a29be811f786415fc1e6fd/propcache-0.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:381914df18634f5494334d201e98245c0596067504b9372d8cf93f4bb23e025e", size = 40790, upload_time = "2025-10-08T19:47:26.847Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/59/1b/e71ae98235f8e2ba5004d8cb19765a74877abf189bc53fc0c80d799e56c3/propcache-0.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:8873eb4460fd55333ea49b7d189749ecf6e55bf85080f11b1c4530ed3034cba1", size = 37158, upload_time = "2025-10-08T19:47:27.961Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/83/ce/a31bbdfc24ee0dcbba458c8175ed26089cf109a55bbe7b7640ed2470cfe9/propcache-0.4.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:92d1935ee1f8d7442da9c0c4fa7ac20d07e94064184811b685f5c4fada64553b", size = 81451, upload_time = "2025-10-08T19:47:29.445Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/25/9c/442a45a470a68456e710d96cacd3573ef26a1d0a60067e6a7d5e655621ed/propcache-0.4.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:473c61b39e1460d386479b9b2f337da492042447c9b685f28be4f74d3529e566", size = 46374, upload_time = "2025-10-08T19:47:30.579Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f4/bf/b1d5e21dbc3b2e889ea4327044fb16312a736d97640fb8b6aa3f9c7b3b65/propcache-0.4.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:c0ef0aaafc66fbd87842a3fe3902fd889825646bc21149eafe47be6072725835", size = 48396, upload_time = "2025-10-08T19:47:31.79Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f4/04/5b4c54a103d480e978d3c8a76073502b18db0c4bc17ab91b3cb5092ad949/propcache-0.4.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f95393b4d66bfae908c3ca8d169d5f79cd65636ae15b5e7a4f6e67af675adb0e", size = 275950, upload_time = "2025-10-08T19:47:33.481Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b4/c1/86f846827fb969c4b78b0af79bba1d1ea2156492e1b83dea8b8a6ae27395/propcache-0.4.1-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c07fda85708bc48578467e85099645167a955ba093be0a2dcba962195676e859", size = 273856, upload_time = "2025-10-08T19:47:34.906Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/36/1d/fc272a63c8d3bbad6878c336c7a7dea15e8f2d23a544bda43205dfa83ada/propcache-0.4.1-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:af223b406d6d000830c6f65f1e6431783fc3f713ba3e6cc8c024d5ee96170a4b", size = 280420, upload_time = "2025-10-08T19:47:36.338Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/07/0c/01f2219d39f7e53d52e5173bcb09c976609ba30209912a0680adfb8c593a/propcache-0.4.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a78372c932c90ee474559c5ddfffd718238e8673c340dc21fe45c5b8b54559a0", size = 263254, upload_time = "2025-10-08T19:47:37.692Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2d/18/cd28081658ce597898f0c4d174d4d0f3c5b6d4dc27ffafeef835c95eb359/propcache-0.4.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:564d9f0d4d9509e1a870c920a89b2fec951b44bf5ba7d537a9e7c1ccec2c18af", size = 261205, upload_time = "2025-10-08T19:47:39.659Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/7a/71/1f9e22eb8b8316701c2a19fa1f388c8a3185082607da8e406a803c9b954e/propcache-0.4.1-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:17612831fda0138059cc5546f4d12a2aacfb9e47068c06af35c400ba58ba7393", size = 247873, upload_time = "2025-10-08T19:47:41.084Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/4a/65/3d4b61f36af2b4eddba9def857959f1016a51066b4f1ce348e0cf7881f58/propcache-0.4.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:41a89040cb10bd345b3c1a873b2bf36413d48da1def52f268a055f7398514874", size = 262739, upload_time = "2025-10-08T19:47:42.51Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2a/42/26746ab087faa77c1c68079b228810436ccd9a5ce9ac85e2b7307195fd06/propcache-0.4.1-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:e35b88984e7fa64aacecea39236cee32dd9bd8c55f57ba8a75cf2399553f9bd7", size = 263514, upload_time = "2025-10-08T19:47:43.927Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/94/13/630690fe201f5502d2403dd3cfd451ed8858fe3c738ee88d095ad2ff407b/propcache-0.4.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6f8b465489f927b0df505cbe26ffbeed4d6d8a2bbc61ce90eb074ff129ef0ab1", size = 257781, upload_time = "2025-10-08T19:47:45.448Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/92/f7/1d4ec5841505f423469efbfc381d64b7b467438cd5a4bbcbb063f3b73d27/propcache-0.4.1-cp313-cp313t-win32.whl", hash = "sha256:2ad890caa1d928c7c2965b48f3a3815c853180831d0e5503d35cf00c472f4717", size = 41396, upload_time = "2025-10-08T19:47:47.202Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/48/f0/615c30622316496d2cbbc29f5985f7777d3ada70f23370608c1d3e081c1f/propcache-0.4.1-cp313-cp313t-win_amd64.whl", hash = "sha256:f7ee0e597f495cf415bcbd3da3caa3bd7e816b74d0d52b8145954c5e6fd3ff37", size = 44897, upload_time = "2025-10-08T19:47:48.336Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fd/ca/6002e46eccbe0e33dcd4069ef32f7f1c9e243736e07adca37ae8c4830ec3/propcache-0.4.1-cp313-cp313t-win_arm64.whl", hash = "sha256:929d7cbe1f01bb7baffb33dc14eb5691c95831450a26354cd210a8155170c93a", size = 39789, upload_time = "2025-10-08T19:47:49.876Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8e/5c/bca52d654a896f831b8256683457ceddd490ec18d9ec50e97dfd8fc726a8/propcache-0.4.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3f7124c9d820ba5548d431afb4632301acf965db49e666aa21c305cbe8c6de12", size = 78152, upload_time = "2025-10-08T19:47:51.051Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/65/9b/03b04e7d82a5f54fb16113d839f5ea1ede58a61e90edf515f6577c66fa8f/propcache-0.4.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:c0d4b719b7da33599dfe3b22d3db1ef789210a0597bc650b7cee9c77c2be8c5c", size = 44869, upload_time = "2025-10-08T19:47:52.594Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b2/fa/89a8ef0468d5833a23fff277b143d0573897cf75bd56670a6d28126c7d68/propcache-0.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9f302f4783709a78240ebc311b793f123328716a60911d667e0c036bc5dcbded", size = 46596, upload_time = "2025-10-08T19:47:54.073Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/86/bd/47816020d337f4a746edc42fe8d53669965138f39ee117414c7d7a340cfe/propcache-0.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c80ee5802e3fb9ea37938e7eecc307fb984837091d5fd262bb37238b1ae97641", size = 206981, upload_time = "2025-10-08T19:47:55.715Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/df/f6/c5fa1357cc9748510ee55f37173eb31bfde6d94e98ccd9e6f033f2fc06e1/propcache-0.4.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ed5a841e8bb29a55fb8159ed526b26adc5bdd7e8bd7bf793ce647cb08656cdf4", size = 211490, upload_time = "2025-10-08T19:47:57.499Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/80/1e/e5889652a7c4a3846683401a48f0f2e5083ce0ec1a8a5221d8058fbd1adf/propcache-0.4.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:55c72fd6ea2da4c318e74ffdf93c4fe4e926051133657459131a95c846d16d44", size = 215371, upload_time = "2025-10-08T19:47:59.317Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b2/f2/889ad4b2408f72fe1a4f6a19491177b30ea7bf1a0fd5f17050ca08cfc882/propcache-0.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8326e144341460402713f91df60ade3c999d601e7eb5ff8f6f7862d54de0610d", size = 201424, upload_time = "2025-10-08T19:48:00.67Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/27/73/033d63069b57b0812c8bd19f311faebeceb6ba31b8f32b73432d12a0b826/propcache-0.4.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:060b16ae65bc098da7f6d25bf359f1f31f688384858204fe5d652979e0015e5b", size = 197566, upload_time = "2025-10-08T19:48:02.604Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/dc/89/ce24f3dc182630b4e07aa6d15f0ff4b14ed4b9955fae95a0b54c58d66c05/propcache-0.4.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:89eb3fa9524f7bec9de6e83cf3faed9d79bffa560672c118a96a171a6f55831e", size = 193130, upload_time = "2025-10-08T19:48:04.499Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a9/24/ef0d5fd1a811fb5c609278d0209c9f10c35f20581fcc16f818da959fc5b4/propcache-0.4.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:dee69d7015dc235f526fe80a9c90d65eb0039103fe565776250881731f06349f", size = 202625, upload_time = "2025-10-08T19:48:06.213Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f5/02/98ec20ff5546f68d673df2f7a69e8c0d076b5abd05ca882dc7ee3a83653d/propcache-0.4.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:5558992a00dfd54ccbc64a32726a3357ec93825a418a401f5cc67df0ac5d9e49", size = 204209, upload_time = "2025-10-08T19:48:08.432Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a0/87/492694f76759b15f0467a2a93ab68d32859672b646aa8a04ce4864e7932d/propcache-0.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c9b822a577f560fbd9554812526831712c1436d2c046cedee4c3796d3543b144", size = 197797, upload_time = "2025-10-08T19:48:09.968Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ee/36/66367de3575db1d2d3f3d177432bd14ee577a39d3f5d1b3d5df8afe3b6e2/propcache-0.4.1-cp314-cp314-win32.whl", hash = "sha256:ab4c29b49d560fe48b696cdcb127dd36e0bc2472548f3bf56cc5cb3da2b2984f", size = 38140, upload_time = "2025-10-08T19:48:11.232Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0c/2a/a758b47de253636e1b8aef181c0b4f4f204bf0dd964914fb2af90a95b49b/propcache-0.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:5a103c3eb905fcea0ab98be99c3a9a5ab2de60228aa5aceedc614c0281cf6153", size = 41257, upload_time = "2025-10-08T19:48:12.707Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/34/5e/63bd5896c3fec12edcbd6f12508d4890d23c265df28c74b175e1ef9f4f3b/propcache-0.4.1-cp314-cp314-win_arm64.whl", hash = "sha256:74c1fb26515153e482e00177a1ad654721bf9207da8a494a0c05e797ad27b992", size = 38097, upload_time = "2025-10-08T19:48:13.923Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/99/85/9ff785d787ccf9bbb3f3106f79884a130951436f58392000231b4c737c80/propcache-0.4.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:824e908bce90fb2743bd6b59db36eb4f45cd350a39637c9f73b1c1ea66f5b75f", size = 81455, upload_time = "2025-10-08T19:48:15.16Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/90/85/2431c10c8e7ddb1445c1f7c4b54d886e8ad20e3c6307e7218f05922cad67/propcache-0.4.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:c2b5e7db5328427c57c8e8831abda175421b709672f6cfc3d630c3b7e2146393", size = 46372, upload_time = "2025-10-08T19:48:16.424Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/01/20/b0972d902472da9bcb683fa595099911f4d2e86e5683bcc45de60dd05dc3/propcache-0.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6f6ff873ed40292cd4969ef5310179afd5db59fdf055897e282485043fc80ad0", size = 48411, upload_time = "2025-10-08T19:48:17.577Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e2/e3/7dc89f4f21e8f99bad3d5ddb3a3389afcf9da4ac69e3deb2dcdc96e74169/propcache-0.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:49a2dc67c154db2c1463013594c458881a069fcf98940e61a0569016a583020a", size = 275712, upload_time = "2025-10-08T19:48:18.901Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/20/67/89800c8352489b21a8047c773067644e3897f02ecbbd610f4d46b7f08612/propcache-0.4.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:005f08e6a0529984491e37d8dbc3dd86f84bd78a8ceb5fa9a021f4c48d4984be", size = 273557, upload_time = "2025-10-08T19:48:20.762Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e2/a1/b52b055c766a54ce6d9c16d9aca0cad8059acd9637cdf8aa0222f4a026ef/propcache-0.4.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5c3310452e0d31390da9035c348633b43d7e7feb2e37be252be6da45abd1abcc", size = 280015, upload_time = "2025-10-08T19:48:22.592Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/48/c8/33cee30bd890672c63743049f3c9e4be087e6780906bfc3ec58528be59c1/propcache-0.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4c3c70630930447f9ef1caac7728c8ad1c56bc5015338b20fed0d08ea2480b3a", size = 262880, upload_time = "2025-10-08T19:48:23.947Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0c/b1/8f08a143b204b418285c88b83d00edbd61afbc2c6415ffafc8905da7038b/propcache-0.4.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8e57061305815dfc910a3634dcf584f08168a8836e6999983569f51a8544cd89", size = 260938, upload_time = "2025-10-08T19:48:25.656Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/cf/12/96e4664c82ca2f31e1c8dff86afb867348979eb78d3cb8546a680287a1e9/propcache-0.4.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:521a463429ef54143092c11a77e04056dd00636f72e8c45b70aaa3140d639726", size = 247641, upload_time = "2025-10-08T19:48:27.207Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/18/ed/e7a9cfca28133386ba52278136d42209d3125db08d0a6395f0cba0c0285c/propcache-0.4.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:120c964da3fdc75e3731aa392527136d4ad35868cc556fd09bb6d09172d9a367", size = 262510, upload_time = "2025-10-08T19:48:28.65Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f5/76/16d8bf65e8845dd62b4e2b57444ab81f07f40caa5652b8969b87ddcf2ef6/propcache-0.4.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:d8f353eb14ee3441ee844ade4277d560cdd68288838673273b978e3d6d2c8f36", size = 263161, upload_time = "2025-10-08T19:48:30.133Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e7/70/c99e9edb5d91d5ad8a49fa3c1e8285ba64f1476782fed10ab251ff413ba1/propcache-0.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ab2943be7c652f09638800905ee1bab2c544e537edb57d527997a24c13dc1455", size = 257393, upload_time = "2025-10-08T19:48:31.567Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/08/02/87b25304249a35c0915d236575bc3574a323f60b47939a2262b77632a3ee/propcache-0.4.1-cp314-cp314t-win32.whl", hash = "sha256:05674a162469f31358c30bcaa8883cb7829fa3110bf9c0991fe27d7896c42d85", size = 42546, upload_time = "2025-10-08T19:48:32.872Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/cb/ef/3c6ecf8b317aa982f309835e8f96987466123c6e596646d4e6a1dfcd080f/propcache-0.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:990f6b3e2a27d683cb7602ed6c86f15ee6b43b1194736f9baaeb93d0016633b1", size = 46259, upload_time = "2025-10-08T19:48:34.226Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c4/2d/346e946d4951f37eca1e4f55be0f0174c52cd70720f84029b02f296f4a38/propcache-0.4.1-cp314-cp314t-win_arm64.whl", hash = "sha256:ecef2343af4cc68e05131e45024ba34f6095821988a9d0a02aa7c73fcc448aa9", size = 40428, upload_time = "2025-10-08T19:48:35.441Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5b/5a/bc7b4a4ef808fa59a816c17b20c4bef6884daebbdf627ff2a161da67da19/propcache-0.4.1-py3-none-any.whl", hash = "sha256:af2a6052aeb6cf17d3e46ee169099044fd8224cbaf75c76a2ef596e8163e2237", size = 13305, upload_time = "2025-10-08T19:49:00.792Z" }, +] + +[[package]] +name = "pyarrow" +version = "22.0.0" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/30/53/04a7fdc63e6056116c9ddc8b43bc28c12cdd181b85cbeadb79278475f3ae/pyarrow-22.0.0.tar.gz", hash = "sha256:3d600dc583260d845c7d8a6db540339dd883081925da2bd1c5cb808f720b3cd9", size = 1151151, upload_time = "2025-10-24T12:30:00.762Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d9/9b/cb3f7e0a345353def531ca879053e9ef6b9f38ed91aebcf68b09ba54dec0/pyarrow-22.0.0-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:77718810bd3066158db1e95a63c160ad7ce08c6b0710bc656055033e39cdad88", size = 34223968, upload_time = "2025-10-24T10:03:31.21Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6c/41/3184b8192a120306270c5307f105b70320fdaa592c99843c5ef78aaefdcf/pyarrow-22.0.0-cp310-cp310-macosx_12_0_x86_64.whl", hash = "sha256:44d2d26cda26d18f7af7db71453b7b783788322d756e81730acb98f24eb90ace", size = 35942085, upload_time = "2025-10-24T10:03:38.146Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d9/3d/a1eab2f6f08001f9fb714b8ed5cfb045e2fe3e3e3c0c221f2c9ed1e6d67d/pyarrow-22.0.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:b9d71701ce97c95480fecb0039ec5bb889e75f110da72005743451339262f4ce", size = 44964613, upload_time = "2025-10-24T10:03:46.516Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/46/46/a1d9c24baf21cfd9ce994ac820a24608decf2710521b29223d4334985127/pyarrow-22.0.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:710624ab925dc2b05a6229d47f6f0dac1c1155e6ed559be7109f684eba048a48", size = 47627059, upload_time = "2025-10-24T10:03:55.353Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3a/4c/f711acb13075c1391fd54bc17e078587672c575f8de2a6e62509af026dcf/pyarrow-22.0.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:f963ba8c3b0199f9d6b794c90ec77545e05eadc83973897a4523c9e8d84e9340", size = 47947043, upload_time = "2025-10-24T10:04:05.408Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/4e/70/1f3180dd7c2eab35c2aca2b29ace6c519f827dcd4cfeb8e0dca41612cf7a/pyarrow-22.0.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:bd0d42297ace400d8febe55f13fdf46e86754842b860c978dfec16f081e5c653", size = 50206505, upload_time = "2025-10-24T10:04:15.786Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/80/07/fea6578112c8c60ffde55883a571e4c4c6bc7049f119d6b09333b5cc6f73/pyarrow-22.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:00626d9dc0f5ef3a75fe63fd68b9c7c8302d2b5bbc7f74ecaedba83447a24f84", size = 28101641, upload_time = "2025-10-24T10:04:22.57Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2e/b7/18f611a8cdc43417f9394a3ccd3eace2f32183c08b9eddc3d17681819f37/pyarrow-22.0.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:3e294c5eadfb93d78b0763e859a0c16d4051fc1c5231ae8956d61cb0b5666f5a", size = 34272022, upload_time = "2025-10-24T10:04:28.973Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/26/5c/f259e2526c67eb4b9e511741b19870a02363a47a35edbebc55c3178db22d/pyarrow-22.0.0-cp311-cp311-macosx_12_0_x86_64.whl", hash = "sha256:69763ab2445f632d90b504a815a2a033f74332997052b721002298ed6de40f2e", size = 35995834, upload_time = "2025-10-24T10:04:35.467Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/50/8d/281f0f9b9376d4b7f146913b26fac0aa2829cd1ee7e997f53a27411bbb92/pyarrow-22.0.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:b41f37cabfe2463232684de44bad753d6be08a7a072f6a83447eeaf0e4d2a215", size = 45030348, upload_time = "2025-10-24T10:04:43.366Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f5/e5/53c0a1c428f0976bf22f513d79c73000926cb00b9c138d8e02daf2102e18/pyarrow-22.0.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:35ad0f0378c9359b3f297299c3309778bb03b8612f987399a0333a560b43862d", size = 47699480, upload_time = "2025-10-24T10:04:51.486Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/95/e1/9dbe4c465c3365959d183e6345d0a8d1dc5b02ca3f8db4760b3bc834cf25/pyarrow-22.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8382ad21458075c2e66a82a29d650f963ce51c7708c7c0ff313a8c206c4fd5e8", size = 48011148, upload_time = "2025-10-24T10:04:59.585Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c5/b4/7caf5d21930061444c3cf4fa7535c82faf5263e22ce43af7c2759ceb5b8b/pyarrow-22.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1a812a5b727bc09c3d7ea072c4eebf657c2f7066155506ba31ebf4792f88f016", size = 50276964, upload_time = "2025-10-24T10:05:08.175Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ae/f3/cec89bd99fa3abf826f14d4e53d3d11340ce6f6af4d14bdcd54cd83b6576/pyarrow-22.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:ec5d40dd494882704fb876c16fa7261a69791e784ae34e6b5992e977bd2e238c", size = 28106517, upload_time = "2025-10-24T10:05:14.314Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/af/63/ba23862d69652f85b615ca14ad14f3bcfc5bf1b99ef3f0cd04ff93fdad5a/pyarrow-22.0.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:bea79263d55c24a32b0d79c00a1c58bb2ee5f0757ed95656b01c0fb310c5af3d", size = 34211578, upload_time = "2025-10-24T10:05:21.583Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b1/d0/f9ad86fe809efd2bcc8be32032fa72e8b0d112b01ae56a053006376c5930/pyarrow-22.0.0-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:12fe549c9b10ac98c91cf791d2945e878875d95508e1a5d14091a7aaa66d9cf8", size = 35989906, upload_time = "2025-10-24T10:05:29.485Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b4/a8/f910afcb14630e64d673f15904ec27dd31f1e009b77033c365c84e8c1e1d/pyarrow-22.0.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:334f900ff08ce0423407af97e6c26ad5d4e3b0763645559ece6fbf3747d6a8f5", size = 45021677, upload_time = "2025-10-24T10:05:38.274Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/13/95/aec81f781c75cd10554dc17a25849c720d54feafb6f7847690478dcf5ef8/pyarrow-22.0.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:c6c791b09c57ed76a18b03f2631753a4960eefbbca80f846da8baefc6491fcfe", size = 47726315, upload_time = "2025-10-24T10:05:47.314Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/bb/d4/74ac9f7a54cfde12ee42734ea25d5a3c9a45db78f9def949307a92720d37/pyarrow-22.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c3200cb41cdbc65156e5f8c908d739b0dfed57e890329413da2748d1a2cd1a4e", size = 47990906, upload_time = "2025-10-24T10:05:58.254Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2e/71/fedf2499bf7a95062eafc989ace56572f3343432570e1c54e6599d5b88da/pyarrow-22.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ac93252226cf288753d8b46280f4edf3433bf9508b6977f8dd8526b521a1bbb9", size = 50306783, upload_time = "2025-10-24T10:06:08.08Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/68/ed/b202abd5a5b78f519722f3d29063dda03c114711093c1995a33b8e2e0f4b/pyarrow-22.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:44729980b6c50a5f2bfcc2668d36c569ce17f8b17bccaf470c4313dcbbf13c9d", size = 27972883, upload_time = "2025-10-24T10:06:14.204Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a6/d6/d0fac16a2963002fc22c8fa75180a838737203d558f0ed3b564c4a54eef5/pyarrow-22.0.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:e6e95176209257803a8b3d0394f21604e796dadb643d2f7ca21b66c9c0b30c9a", size = 34204629, upload_time = "2025-10-24T10:06:20.274Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c6/9c/1d6357347fbae062ad3f17082f9ebc29cc733321e892c0d2085f42a2212b/pyarrow-22.0.0-cp313-cp313-macosx_12_0_x86_64.whl", hash = "sha256:001ea83a58024818826a9e3f89bf9310a114f7e26dfe404a4c32686f97bd7901", size = 35985783, upload_time = "2025-10-24T10:06:27.301Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ff/c0/782344c2ce58afbea010150df07e3a2f5fdad299cd631697ae7bd3bac6e3/pyarrow-22.0.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:ce20fe000754f477c8a9125543f1936ea5b8867c5406757c224d745ed033e691", size = 45020999, upload_time = "2025-10-24T10:06:35.387Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/1b/8b/5362443737a5307a7b67c1017c42cd104213189b4970bf607e05faf9c525/pyarrow-22.0.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:e0a15757fccb38c410947df156f9749ae4a3c89b2393741a50521f39a8cf202a", size = 47724601, upload_time = "2025-10-24T10:06:43.551Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/69/4d/76e567a4fc2e190ee6072967cb4672b7d9249ac59ae65af2d7e3047afa3b/pyarrow-22.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cedb9dd9358e4ea1d9bce3665ce0797f6adf97ff142c8e25b46ba9cdd508e9b6", size = 48001050, upload_time = "2025-10-24T10:06:52.284Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/01/5e/5653f0535d2a1aef8223cee9d92944cb6bccfee5cf1cd3f462d7cb022790/pyarrow-22.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:252be4a05f9d9185bb8c18e83764ebcfea7185076c07a7a662253af3a8c07941", size = 50307877, upload_time = "2025-10-24T10:07:02.405Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2d/f8/1d0bd75bf9328a3b826e24a16e5517cd7f9fbf8d34a3184a4566ef5a7f29/pyarrow-22.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:a4893d31e5ef780b6edcaf63122df0f8d321088bb0dee4c8c06eccb1ca28d145", size = 27977099, upload_time = "2025-10-24T10:08:07.259Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/90/81/db56870c997805bf2b0f6eeeb2d68458bf4654652dccdcf1bf7a42d80903/pyarrow-22.0.0-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:f7fe3dbe871294ba70d789be16b6e7e52b418311e166e0e3cba9522f0f437fb1", size = 34336685, upload_time = "2025-10-24T10:07:11.47Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/1c/98/0727947f199aba8a120f47dfc229eeb05df15bcd7a6f1b669e9f882afc58/pyarrow-22.0.0-cp313-cp313t-macosx_12_0_x86_64.whl", hash = "sha256:ba95112d15fd4f1105fb2402c4eab9068f0554435e9b7085924bcfaac2cc306f", size = 36032158, upload_time = "2025-10-24T10:07:18.626Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/96/b4/9babdef9c01720a0785945c7cf550e4acd0ebcd7bdd2e6f0aa7981fa85e2/pyarrow-22.0.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:c064e28361c05d72eed8e744c9605cbd6d2bb7481a511c74071fd9b24bc65d7d", size = 44892060, upload_time = "2025-10-24T10:07:26.002Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f8/ca/2f8804edd6279f78a37062d813de3f16f29183874447ef6d1aadbb4efa0f/pyarrow-22.0.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:6f9762274496c244d951c819348afbcf212714902742225f649cf02823a6a10f", size = 47504395, upload_time = "2025-10-24T10:07:34.09Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b9/f0/77aa5198fd3943682b2e4faaf179a674f0edea0d55d326d83cb2277d9363/pyarrow-22.0.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a9d9ffdc2ab696f6b15b4d1f7cec6658e1d788124418cb30030afbae31c64746", size = 48066216, upload_time = "2025-10-24T10:07:43.528Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/79/87/a1937b6e78b2aff18b706d738c9e46ade5bfcf11b294e39c87706a0089ac/pyarrow-22.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:ec1a15968a9d80da01e1d30349b2b0d7cc91e96588ee324ce1b5228175043e95", size = 50288552, upload_time = "2025-10-24T10:07:53.519Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/60/ae/b5a5811e11f25788ccfdaa8f26b6791c9807119dffcf80514505527c384c/pyarrow-22.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:bba208d9c7decf9961998edf5c65e3ea4355d5818dd6cd0f6809bec1afb951cc", size = 28262504, upload_time = "2025-10-24T10:08:00.932Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/bd/b0/0fa4d28a8edb42b0a7144edd20befd04173ac79819547216f8a9f36f9e50/pyarrow-22.0.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:9bddc2cade6561f6820d4cd73f99a0243532ad506bc510a75a5a65a522b2d74d", size = 34224062, upload_time = "2025-10-24T10:08:14.101Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0f/a8/7a719076b3c1be0acef56a07220c586f25cd24de0e3f3102b438d18ae5df/pyarrow-22.0.0-cp314-cp314-macosx_12_0_x86_64.whl", hash = "sha256:e70ff90c64419709d38c8932ea9fe1cc98415c4f87ea8da81719e43f02534bc9", size = 35990057, upload_time = "2025-10-24T10:08:21.842Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/89/3c/359ed54c93b47fb6fe30ed16cdf50e3f0e8b9ccfb11b86218c3619ae50a8/pyarrow-22.0.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:92843c305330aa94a36e706c16209cd4df274693e777ca47112617db7d0ef3d7", size = 45068002, upload_time = "2025-10-24T10:08:29.034Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/55/fc/4945896cc8638536ee787a3bd6ce7cec8ec9acf452d78ec39ab328efa0a1/pyarrow-22.0.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:6dda1ddac033d27421c20d7a7943eec60be44e0db4e079f33cc5af3b8280ccde", size = 47737765, upload_time = "2025-10-24T10:08:38.559Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/cd/5e/7cb7edeb2abfaa1f79b5d5eb89432356155c8426f75d3753cbcb9592c0fd/pyarrow-22.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:84378110dd9a6c06323b41b56e129c504d157d1a983ce8f5443761eb5256bafc", size = 48048139, upload_time = "2025-10-24T10:08:46.784Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/88/c6/546baa7c48185f5e9d6e59277c4b19f30f48c94d9dd938c2a80d4d6b067c/pyarrow-22.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:854794239111d2b88b40b6ef92aa478024d1e5074f364033e73e21e3f76b25e0", size = 50314244, upload_time = "2025-10-24T10:08:55.771Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3c/79/755ff2d145aafec8d347bf18f95e4e81c00127f06d080135dfc86aea417c/pyarrow-22.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:b883fe6fd85adad7932b3271c38ac289c65b7337c2c132e9569f9d3940620730", size = 28757501, upload_time = "2025-10-24T10:09:59.891Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0e/d2/237d75ac28ced3147912954e3c1a174df43a95f4f88e467809118a8165e0/pyarrow-22.0.0-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:7a820d8ae11facf32585507c11f04e3f38343c1e784c9b5a8b1da5c930547fe2", size = 34355506, upload_time = "2025-10-24T10:09:02.953Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/1e/2c/733dfffe6d3069740f98e57ff81007809067d68626c5faef293434d11bd6/pyarrow-22.0.0-cp314-cp314t-macosx_12_0_x86_64.whl", hash = "sha256:c6ec3675d98915bf1ec8b3c7986422682f7232ea76cad276f4c8abd5b7319b70", size = 36047312, upload_time = "2025-10-24T10:09:10.334Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/7c/2b/29d6e3782dc1f299727462c1543af357a0f2c1d3c160ce199950d9ca51eb/pyarrow-22.0.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:3e739edd001b04f654b166204fc7a9de896cf6007eaff33409ee9e50ceaff754", size = 45081609, upload_time = "2025-10-24T10:09:18.61Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8d/42/aa9355ecc05997915af1b7b947a7f66c02dcaa927f3203b87871c114ba10/pyarrow-22.0.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:7388ac685cab5b279a41dfe0a6ccd99e4dbf322edfb63e02fc0443bf24134e91", size = 47703663, upload_time = "2025-10-24T10:09:27.369Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ee/62/45abedde480168e83a1de005b7b7043fd553321c1e8c5a9a114425f64842/pyarrow-22.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:f633074f36dbc33d5c05b5dc75371e5660f1dbf9c8b1d95669def05e5425989c", size = 48066543, upload_time = "2025-10-24T10:09:34.908Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/84/e9/7878940a5b072e4f3bf998770acafeae13b267f9893af5f6d4ab3904b67e/pyarrow-22.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:4c19236ae2402a8663a2c8f21f1870a03cc57f0bef7e4b6eb3238cc82944de80", size = 50288838, upload_time = "2025-10-24T10:09:44.394Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/7b/03/f335d6c52b4a4761bcc83499789a1e2e16d9d201a58c327a9b5cc9a41bd9/pyarrow-22.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:0c34fe18094686194f204a3b1787a27456897d8a2d62caf84b61e8dfbc0252ae", size = 29185594, upload_time = "2025-10-24T10:09:53.111Z" }, +] + +[[package]] +name = "pyasn1" +version = "0.6.1" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ba/e9/01f1a64245b89f039897cb0130016d79f77d52669aae6ee7b159a6c4c018/pyasn1-0.6.1.tar.gz", hash = "sha256:6f580d2bdd84365380830acf45550f2511469f673cb4a5ae3857a3170128b034", size = 145322, upload_time = "2024-09-10T22:41:42.55Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c8/f1/d6a797abb14f6283c0ddff96bbdd46937f64122b8c925cab503dd37f8214/pyasn1-0.6.1-py3-none-any.whl", hash = "sha256:0d632f46f2ba09143da3a8afe9e33fb6f92fa2320ab7e886e2d0f7672af84629", size = 83135, upload_time = "2024-09-11T16:00:36.122Z" }, +] + +[[package]] +name = "pyasn1-modules" +version = "0.4.2" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +dependencies = [ + { name = "pyasn1" }, +] +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e9/e6/78ebbb10a8c8e4b61a59249394a4a594c1a7af95593dc933a349c8d00964/pyasn1_modules-0.4.2.tar.gz", hash = "sha256:677091de870a80aae844b1ca6134f54652fa2c8c5a52aa396440ac3106e941e6", size = 307892, upload_time = "2025-03-28T02:41:22.17Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/47/8d/d529b5d697919ba8c11ad626e835d4039be708a35b0d22de83a269a6682c/pyasn1_modules-0.4.2-py3-none-any.whl", hash = "sha256:29253a9207ce32b64c3ac6600edc75368f98473906e8fd1043bd6b5b1de2c14a", size = 181259, upload_time = "2025-03-28T02:41:19.028Z" }, +] + +[[package]] +name = "pycparser" +version = "2.23" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fe/cf/d2d3b9f5699fb1e4615c8e32ff220203e43b248e1dfcc6736ad9057731ca/pycparser-2.23.tar.gz", hash = "sha256:78816d4f24add8f10a06d6f05b4d424ad9e96cfebf68a4ddc99c65c0720d00c2", size = 173734, upload_time = "2025-09-09T13:23:47.91Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a0/e3/59cd50310fc9b59512193629e1984c1f95e5c8ae6e5d8c69532ccc65a7fe/pycparser-2.23-py3-none-any.whl", hash = "sha256:e5c6e8d3fbad53479cab09ac03729e0a9faf2bee3db8208a550daf5af81a5934", size = 118140, upload_time = "2025-09-09T13:23:46.651Z" }, +] + +[[package]] +name = "pydantic" +version = "2.12.5" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +dependencies = [ + { name = "annotated-types" }, + { name = "pydantic-core" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, +] +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", hash = "sha256:4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49", size = 821591, upload_time = "2025-11-26T15:11:46.471Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", hash = "sha256:e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d", size = 463580, upload_time = "2025-11-26T15:11:44.605Z" }, +] + +[[package]] +name = "pydantic-core" +version = "2.41.5" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952, upload_time = "2025-11-04T13:43:49.098Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c6/90/32c9941e728d564b411d574d8ee0cf09b12ec978cb22b294995bae5549a5/pydantic_core-2.41.5-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:77b63866ca88d804225eaa4af3e664c5faf3568cea95360d21f4725ab6e07146", size = 2107298, upload_time = "2025-11-04T13:39:04.116Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fb/a8/61c96a77fe28993d9a6fb0f4127e05430a267b235a124545d79fea46dd65/pydantic_core-2.41.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:dfa8a0c812ac681395907e71e1274819dec685fec28273a28905df579ef137e2", size = 1901475, upload_time = "2025-11-04T13:39:06.055Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5d/b6/338abf60225acc18cdc08b4faef592d0310923d19a87fba1faf05af5346e/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5921a4d3ca3aee735d9fd163808f5e8dd6c6972101e4adbda9a4667908849b97", size = 1918815, upload_time = "2025-11-04T13:39:10.41Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d1/1c/2ed0433e682983d8e8cba9c8d8ef274d4791ec6a6f24c58935b90e780e0a/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e25c479382d26a2a41b7ebea1043564a937db462816ea07afa8a44c0866d52f9", size = 2065567, upload_time = "2025-11-04T13:39:12.244Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b3/24/cf84974ee7d6eae06b9e63289b7b8f6549d416b5c199ca2d7ce13bbcf619/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f547144f2966e1e16ae626d8ce72b4cfa0caedc7fa28052001c94fb2fcaa1c52", size = 2230442, upload_time = "2025-11-04T13:39:13.962Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fd/21/4e287865504b3edc0136c89c9c09431be326168b1eb7841911cbc877a995/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6f52298fbd394f9ed112d56f3d11aabd0d5bd27beb3084cc3d8ad069483b8941", size = 2350956, upload_time = "2025-11-04T13:39:15.889Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a8/76/7727ef2ffa4b62fcab916686a68a0426b9b790139720e1934e8ba797e238/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:100baa204bb412b74fe285fb0f3a385256dad1d1879f0a5cb1499ed2e83d132a", size = 2068253, upload_time = "2025-11-04T13:39:17.403Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d5/8c/a4abfc79604bcb4c748e18975c44f94f756f08fb04218d5cb87eb0d3a63e/pydantic_core-2.41.5-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:05a2c8852530ad2812cb7914dc61a1125dc4e06252ee98e5638a12da6cc6fb6c", size = 2177050, upload_time = "2025-11-04T13:39:19.351Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/67/b1/de2e9a9a79b480f9cb0b6e8b6ba4c50b18d4e89852426364c66aa82bb7b3/pydantic_core-2.41.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:29452c56df2ed968d18d7e21f4ab0ac55e71dc59524872f6fc57dcf4a3249ed2", size = 2147178, upload_time = "2025-11-04T13:39:21Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/16/c1/dfb33f837a47b20417500efaa0378adc6635b3c79e8369ff7a03c494b4ac/pydantic_core-2.41.5-cp310-cp310-musllinux_1_1_armv7l.whl", hash = "sha256:d5160812ea7a8a2ffbe233d8da666880cad0cbaf5d4de74ae15c313213d62556", size = 2341833, upload_time = "2025-11-04T13:39:22.606Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/47/36/00f398642a0f4b815a9a558c4f1dca1b4020a7d49562807d7bc9ff279a6c/pydantic_core-2.41.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:df3959765b553b9440adfd3c795617c352154e497a4eaf3752555cfb5da8fc49", size = 2321156, upload_time = "2025-11-04T13:39:25.843Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/7e/70/cad3acd89fde2010807354d978725ae111ddf6d0ea46d1ea1775b5c1bd0c/pydantic_core-2.41.5-cp310-cp310-win32.whl", hash = "sha256:1f8d33a7f4d5a7889e60dc39856d76d09333d8a6ed0f5f1190635cbec70ec4ba", size = 1989378, upload_time = "2025-11-04T13:39:27.92Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/76/92/d338652464c6c367e5608e4488201702cd1cbb0f33f7b6a85a60fe5f3720/pydantic_core-2.41.5-cp310-cp310-win_amd64.whl", hash = "sha256:62de39db01b8d593e45871af2af9e497295db8d73b085f6bfd0b18c83c70a8f9", size = 2013622, upload_time = "2025-11-04T13:39:29.848Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e8/72/74a989dd9f2084b3d9530b0915fdda64ac48831c30dbf7c72a41a5232db8/pydantic_core-2.41.5-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a3a52f6156e73e7ccb0f8cced536adccb7042be67cb45f9562e12b319c119da6", size = 2105873, upload_time = "2025-11-04T13:39:31.373Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/12/44/37e403fd9455708b3b942949e1d7febc02167662bf1a7da5b78ee1ea2842/pydantic_core-2.41.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7f3bf998340c6d4b0c9a2f02d6a400e51f123b59565d74dc60d252ce888c260b", size = 1899826, upload_time = "2025-11-04T13:39:32.897Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/33/7f/1d5cab3ccf44c1935a359d51a8a2a9e1a654b744b5e7f80d41b88d501eec/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:378bec5c66998815d224c9ca994f1e14c0c21cb95d2f52b6021cc0b2a58f2a5a", size = 1917869, upload_time = "2025-11-04T13:39:34.469Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6e/6a/30d94a9674a7fe4f4744052ed6c5e083424510be1e93da5bc47569d11810/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e7b576130c69225432866fe2f4a469a85a54ade141d96fd396dffcf607b558f8", size = 2063890, upload_time = "2025-11-04T13:39:36.053Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/50/be/76e5d46203fcb2750e542f32e6c371ffa9b8ad17364cf94bb0818dbfb50c/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6cb58b9c66f7e4179a2d5e0f849c48eff5c1fca560994d6eb6543abf955a149e", size = 2229740, upload_time = "2025-11-04T13:39:37.753Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d3/ee/fed784df0144793489f87db310a6bbf8118d7b630ed07aa180d6067e653a/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:88942d3a3dff3afc8288c21e565e476fc278902ae4d6d134f1eeda118cc830b1", size = 2350021, upload_time = "2025-11-04T13:39:40.94Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c8/be/8fed28dd0a180dca19e72c233cbf58efa36df055e5b9d90d64fd1740b828/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f31d95a179f8d64d90f6831d71fa93290893a33148d890ba15de25642c5d075b", size = 2066378, upload_time = "2025-11-04T13:39:42.523Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b0/3b/698cf8ae1d536a010e05121b4958b1257f0b5522085e335360e53a6b1c8b/pydantic_core-2.41.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c1df3d34aced70add6f867a8cf413e299177e0c22660cc767218373d0779487b", size = 2175761, upload_time = "2025-11-04T13:39:44.553Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b8/ba/15d537423939553116dea94ce02f9c31be0fa9d0b806d427e0308ec17145/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:4009935984bd36bd2c774e13f9a09563ce8de4abaa7226f5108262fa3e637284", size = 2146303, upload_time = "2025-11-04T13:39:46.238Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/58/7f/0de669bf37d206723795f9c90c82966726a2ab06c336deba4735b55af431/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:34a64bc3441dc1213096a20fe27e8e128bd3ff89921706e83c0b1ac971276594", size = 2340355, upload_time = "2025-11-04T13:39:48.002Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e5/de/e7482c435b83d7e3c3ee5ee4451f6e8973cff0eb6007d2872ce6383f6398/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c9e19dd6e28fdcaa5a1de679aec4141f691023916427ef9bae8584f9c2fb3b0e", size = 2319875, upload_time = "2025-11-04T13:39:49.705Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fe/e6/8c9e81bb6dd7560e33b9053351c29f30c8194b72f2d6932888581f503482/pydantic_core-2.41.5-cp311-cp311-win32.whl", hash = "sha256:2c010c6ded393148374c0f6f0bf89d206bf3217f201faa0635dcd56bd1520f6b", size = 1987549, upload_time = "2025-11-04T13:39:51.842Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/11/66/f14d1d978ea94d1bc21fc98fcf570f9542fe55bfcc40269d4e1a21c19bf7/pydantic_core-2.41.5-cp311-cp311-win_amd64.whl", hash = "sha256:76ee27c6e9c7f16f47db7a94157112a2f3a00e958bc626e2f4ee8bec5c328fbe", size = 2011305, upload_time = "2025-11-04T13:39:53.485Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/56/d8/0e271434e8efd03186c5386671328154ee349ff0354d83c74f5caaf096ed/pydantic_core-2.41.5-cp311-cp311-win_arm64.whl", hash = "sha256:4bc36bbc0b7584de96561184ad7f012478987882ebf9f9c389b23f432ea3d90f", size = 1972902, upload_time = "2025-11-04T13:39:56.488Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5f/5d/5f6c63eebb5afee93bcaae4ce9a898f3373ca23df3ccaef086d0233a35a7/pydantic_core-2.41.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f41a7489d32336dbf2199c8c0a215390a751c5b014c2c1c5366e817202e9cdf7", size = 2110990, upload_time = "2025-11-04T13:39:58.079Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/aa/32/9c2e8ccb57c01111e0fd091f236c7b371c1bccea0fa85247ac55b1e2b6b6/pydantic_core-2.41.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:070259a8818988b9a84a449a2a7337c7f430a22acc0859c6b110aa7212a6d9c0", size = 1896003, upload_time = "2025-11-04T13:39:59.956Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/68/b8/a01b53cb0e59139fbc9e4fda3e9724ede8de279097179be4ff31f1abb65a/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69", size = 1919200, upload_time = "2025-11-04T13:40:02.241Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/38/de/8c36b5198a29bdaade07b5985e80a233a5ac27137846f3bc2d3b40a47360/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed2e99c456e3fadd05c991f8f437ef902e00eedf34320ba2b0842bd1c3ca3a75", size = 2052578, upload_time = "2025-11-04T13:40:04.401Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/00/b5/0e8e4b5b081eac6cb3dbb7e60a65907549a1ce035a724368c330112adfdd/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:65840751b72fbfd82c3c640cff9284545342a4f1eb1586ad0636955b261b0b05", size = 2208504, upload_time = "2025-11-04T13:40:06.072Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/77/56/87a61aad59c7c5b9dc8caad5a41a5545cba3810c3e828708b3d7404f6cef/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e536c98a7626a98feb2d3eaf75944ef6f3dbee447e1f841eae16f2f0a72d8ddc", size = 2335816, upload_time = "2025-11-04T13:40:07.835Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c", size = 2075366, upload_time = "2025-11-04T13:40:09.804Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d3/43/ebef01f69baa07a482844faaa0a591bad1ef129253ffd0cdaa9d8a7f72d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d38548150c39b74aeeb0ce8ee1d8e82696f4a4e16ddc6de7b1d8823f7de4b9b5", size = 2171698, upload_time = "2025-11-04T13:40:12.004Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b1/87/41f3202e4193e3bacfc2c065fab7706ebe81af46a83d3e27605029c1f5a6/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c23e27686783f60290e36827f9c626e63154b82b116d7fe9adba1fda36da706c", size = 2132603, upload_time = "2025-11-04T13:40:13.868Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/49/7d/4c00df99cb12070b6bccdef4a195255e6020a550d572768d92cc54dba91a/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:482c982f814460eabe1d3bb0adfdc583387bd4691ef00b90575ca0d2b6fe2294", size = 2329591, upload_time = "2025-11-04T13:40:15.672Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/cc/6a/ebf4b1d65d458f3cda6a7335d141305dfa19bdc61140a884d165a8a1bbc7/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:bfea2a5f0b4d8d43adf9d7b8bf019fb46fdd10a2e5cde477fbcb9d1fa08c68e1", size = 2319068, upload_time = "2025-11-04T13:40:17.532Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/49/3b/774f2b5cd4192d5ab75870ce4381fd89cf218af999515baf07e7206753f0/pydantic_core-2.41.5-cp312-cp312-win32.whl", hash = "sha256:b74557b16e390ec12dca509bce9264c3bbd128f8a2c376eaa68003d7f327276d", size = 1985908, upload_time = "2025-11-04T13:40:19.309Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/86/45/00173a033c801cacf67c190fef088789394feaf88a98a7035b0e40d53dc9/pydantic_core-2.41.5-cp312-cp312-win_amd64.whl", hash = "sha256:1962293292865bca8e54702b08a4f26da73adc83dd1fcf26fbc875b35d81c815", size = 2020145, upload_time = "2025-11-04T13:40:21.548Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f9/22/91fbc821fa6d261b376a3f73809f907cec5ca6025642c463d3488aad22fb/pydantic_core-2.41.5-cp312-cp312-win_arm64.whl", hash = "sha256:1746d4a3d9a794cacae06a5eaaccb4b8643a131d45fbc9af23e353dc0a5ba5c3", size = 1976179, upload_time = "2025-11-04T13:40:23.393Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/87/06/8806241ff1f70d9939f9af039c6c35f2360cf16e93c2ca76f184e76b1564/pydantic_core-2.41.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:941103c9be18ac8daf7b7adca8228f8ed6bb7a1849020f643b3a14d15b1924d9", size = 2120403, upload_time = "2025-11-04T13:40:25.248Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/94/02/abfa0e0bda67faa65fef1c84971c7e45928e108fe24333c81f3bfe35d5f5/pydantic_core-2.41.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:112e305c3314f40c93998e567879e887a3160bb8689ef3d2c04b6cc62c33ac34", size = 1896206, upload_time = "2025-11-04T13:40:27.099Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/15/df/a4c740c0943e93e6500f9eb23f4ca7ec9bf71b19e608ae5b579678c8d02f/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cbaad15cb0c90aa221d43c00e77bb33c93e8d36e0bf74760cd00e732d10a6a0", size = 1919307, upload_time = "2025-11-04T13:40:29.806Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/9a/e3/6324802931ae1d123528988e0e86587c2072ac2e5394b4bc2bc34b61ff6e/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:03ca43e12fab6023fc79d28ca6b39b05f794ad08ec2feccc59a339b02f2b3d33", size = 2063258, upload_time = "2025-11-04T13:40:33.544Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c9/d4/2230d7151d4957dd79c3044ea26346c148c98fbf0ee6ebd41056f2d62ab5/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc799088c08fa04e43144b164feb0c13f9a0bc40503f8df3e9fde58a3c0c101e", size = 2214917, upload_time = "2025-11-04T13:40:35.479Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e6/9f/eaac5df17a3672fef0081b6c1bb0b82b33ee89aa5cec0d7b05f52fd4a1fa/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:97aeba56665b4c3235a0e52b2c2f5ae9cd071b8a8310ad27bddb3f7fb30e9aa2", size = 2332186, upload_time = "2025-11-04T13:40:37.436Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/cf/4e/35a80cae583a37cf15604b44240e45c05e04e86f9cfd766623149297e971/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:406bf18d345822d6c21366031003612b9c77b3e29ffdb0f612367352aab7d586", size = 2073164, upload_time = "2025-11-04T13:40:40.289Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/bf/e3/f6e262673c6140dd3305d144d032f7bd5f7497d3871c1428521f19f9efa2/pydantic_core-2.41.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b93590ae81f7010dbe380cdeab6f515902ebcbefe0b9327cc4804d74e93ae69d", size = 2179146, upload_time = "2025-11-04T13:40:42.809Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/75/c7/20bd7fc05f0c6ea2056a4565c6f36f8968c0924f19b7d97bbfea55780e73/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:01a3d0ab748ee531f4ea6c3e48ad9dac84ddba4b0d82291f87248f2f9de8d740", size = 2137788, upload_time = "2025-11-04T13:40:44.752Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3a/8d/34318ef985c45196e004bc46c6eab2eda437e744c124ef0dbe1ff2c9d06b/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:6561e94ba9dacc9c61bce40e2d6bdc3bfaa0259d3ff36ace3b1e6901936d2e3e", size = 2340133, upload_time = "2025-11-04T13:40:46.66Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/9c/59/013626bf8c78a5a5d9350d12e7697d3d4de951a75565496abd40ccd46bee/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:915c3d10f81bec3a74fbd4faebe8391013ba61e5a1a8d48c4455b923bdda7858", size = 2324852, upload_time = "2025-11-04T13:40:48.575Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/1a/d9/c248c103856f807ef70c18a4f986693a46a8ffe1602e5d361485da502d20/pydantic_core-2.41.5-cp313-cp313-win32.whl", hash = "sha256:650ae77860b45cfa6e2cdafc42618ceafab3a2d9a3811fcfbd3bbf8ac3c40d36", size = 1994679, upload_time = "2025-11-04T13:40:50.619Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/9e/8b/341991b158ddab181cff136acd2552c9f35bd30380422a639c0671e99a91/pydantic_core-2.41.5-cp313-cp313-win_amd64.whl", hash = "sha256:79ec52ec461e99e13791ec6508c722742ad745571f234ea6255bed38c6480f11", size = 2019766, upload_time = "2025-11-04T13:40:52.631Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/73/7d/f2f9db34af103bea3e09735bb40b021788a5e834c81eedb541991badf8f5/pydantic_core-2.41.5-cp313-cp313-win_arm64.whl", hash = "sha256:3f84d5c1b4ab906093bdc1ff10484838aca54ef08de4afa9de0f5f14d69639cd", size = 1981005, upload_time = "2025-11-04T13:40:54.734Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ea/28/46b7c5c9635ae96ea0fbb779e271a38129df2550f763937659ee6c5dbc65/pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a", size = 2119622, upload_time = "2025-11-04T13:40:56.68Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/74/1a/145646e5687e8d9a1e8d09acb278c8535ebe9e972e1f162ed338a622f193/pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14", size = 1891725, upload_time = "2025-11-04T13:40:58.807Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/23/04/e89c29e267b8060b40dca97bfc64a19b2a3cf99018167ea1677d96368273/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1", size = 1915040, upload_time = "2025-11-04T13:41:00.853Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/84/a3/15a82ac7bd97992a82257f777b3583d3e84bdb06ba6858f745daa2ec8a85/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66", size = 2063691, upload_time = "2025-11-04T13:41:03.504Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/74/9b/0046701313c6ef08c0c1cf0e028c67c770a4e1275ca73131563c5f2a310a/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869", size = 2213897, upload_time = "2025-11-04T13:41:05.804Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8a/cd/6bac76ecd1b27e75a95ca3a9a559c643b3afcd2dd62086d4b7a32a18b169/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2", size = 2333302, upload_time = "2025-11-04T13:41:07.809Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/4c/d2/ef2074dc020dd6e109611a8be4449b98cd25e1b9b8a303c2f0fca2f2bcf7/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375", size = 2064877, upload_time = "2025-11-04T13:41:09.827Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/18/66/e9db17a9a763d72f03de903883c057b2592c09509ccfe468187f2a2eef29/pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553", size = 2180680, upload_time = "2025-11-04T13:41:12.379Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d3/9e/3ce66cebb929f3ced22be85d4c2399b8e85b622db77dad36b73c5387f8f8/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90", size = 2138960, upload_time = "2025-11-04T13:41:14.627Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a6/62/205a998f4327d2079326b01abee48e502ea739d174f0a89295c481a2272e/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07", size = 2339102, upload_time = "2025-11-04T13:41:16.868Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3c/0d/f05e79471e889d74d3d88f5bd20d0ed189ad94c2423d81ff8d0000aab4ff/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb", size = 2326039, upload_time = "2025-11-04T13:41:18.934Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ec/e1/e08a6208bb100da7e0c4b288eed624a703f4d129bde2da475721a80cab32/pydantic_core-2.41.5-cp314-cp314-win32.whl", hash = "sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23", size = 1995126, upload_time = "2025-11-04T13:41:21.418Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/48/5d/56ba7b24e9557f99c9237e29f5c09913c81eeb2f3217e40e922353668092/pydantic_core-2.41.5-cp314-cp314-win_amd64.whl", hash = "sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf", size = 2015489, upload_time = "2025-11-04T13:41:24.076Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/4e/bb/f7a190991ec9e3e0ba22e4993d8755bbc4a32925c0b5b42775c03e8148f9/pydantic_core-2.41.5-cp314-cp314-win_arm64.whl", hash = "sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0", size = 1977288, upload_time = "2025-11-04T13:41:26.33Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/92/ed/77542d0c51538e32e15afe7899d79efce4b81eee631d99850edc2f5e9349/pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a", size = 2120255, upload_time = "2025-11-04T13:41:28.569Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/bb/3d/6913dde84d5be21e284439676168b28d8bbba5600d838b9dca99de0fad71/pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3", size = 1863760, upload_time = "2025-11-04T13:41:31.055Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5a/f0/e5e6b99d4191da102f2b0eb9687aaa7f5bea5d9964071a84effc3e40f997/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c", size = 1878092, upload_time = "2025-11-04T13:41:33.21Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/71/48/36fb760642d568925953bcc8116455513d6e34c4beaa37544118c36aba6d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612", size = 2053385, upload_time = "2025-11-04T13:41:35.508Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/20/25/92dc684dd8eb75a234bc1c764b4210cf2646479d54b47bf46061657292a8/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d", size = 2218832, upload_time = "2025-11-04T13:41:37.732Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e2/09/f53e0b05023d3e30357d82eb35835d0f6340ca344720a4599cd663dca599/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9", size = 2327585, upload_time = "2025-11-04T13:41:40Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/aa/4e/2ae1aa85d6af35a39b236b1b1641de73f5a6ac4d5a7509f77b814885760c/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660", size = 2041078, upload_time = "2025-11-04T13:41:42.323Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/cd/13/2e215f17f0ef326fc72afe94776edb77525142c693767fc347ed6288728d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9", size = 2173914, upload_time = "2025-11-04T13:41:45.221Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/02/7a/f999a6dcbcd0e5660bc348a3991c8915ce6599f4f2c6ac22f01d7a10816c/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3", size = 2129560, upload_time = "2025-11-04T13:41:47.474Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3a/b1/6c990ac65e3b4c079a4fb9f5b05f5b013afa0f4ed6780a3dd236d2cbdc64/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf", size = 2329244, upload_time = "2025-11-04T13:41:49.992Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d9/02/3c562f3a51afd4d88fff8dffb1771b30cfdfd79befd9883ee094f5b6c0d8/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470", size = 2331955, upload_time = "2025-11-04T13:41:54.079Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906, upload_time = "2025-11-04T13:41:56.606Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607, upload_time = "2025-11-04T13:41:58.889Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769, upload_time = "2025-11-04T13:42:01.186Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/11/72/90fda5ee3b97e51c494938a4a44c3a35a9c96c19bba12372fb9c634d6f57/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:b96d5f26b05d03cc60f11a7761a5ded1741da411e7fe0909e27a5e6a0cb7b034", size = 2115441, upload_time = "2025-11-04T13:42:39.557Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/1f/53/8942f884fa33f50794f119012dc6a1a02ac43a56407adaac20463df8e98f/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:634e8609e89ceecea15e2d61bc9ac3718caaaa71963717bf3c8f38bfde64242c", size = 1930291, upload_time = "2025-11-04T13:42:42.169Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/79/c8/ecb9ed9cd942bce09fc888ee960b52654fbdbede4ba6c2d6e0d3b1d8b49c/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:93e8740d7503eb008aa2df04d3b9735f845d43ae845e6dcd2be0b55a2da43cd2", size = 1948632, upload_time = "2025-11-04T13:42:44.564Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2e/1b/687711069de7efa6af934e74f601e2a4307365e8fdc404703afc453eab26/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f15489ba13d61f670dcc96772e733aad1a6f9c429cc27574c6cdaed82d0146ad", size = 2138905, upload_time = "2025-11-04T13:42:47.156Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/09/32/59b0c7e63e277fa7911c2fc70ccfb45ce4b98991e7ef37110663437005af/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:7da7087d756b19037bc2c06edc6c170eeef3c3bafcb8f532ff17d64dc427adfd", size = 2110495, upload_time = "2025-11-04T13:42:49.689Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/aa/81/05e400037eaf55ad400bcd318c05bb345b57e708887f07ddb2d20e3f0e98/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:aabf5777b5c8ca26f7824cb4a120a740c9588ed58df9b2d196ce92fba42ff8dc", size = 1915388, upload_time = "2025-11-04T13:42:52.215Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6e/0d/e3549b2399f71d56476b77dbf3cf8937cec5cd70536bdc0e374a421d0599/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c007fe8a43d43b3969e8469004e9845944f1a80e6acd47c150856bb87f230c56", size = 1942879, upload_time = "2025-11-04T13:42:56.483Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f7/07/34573da085946b6a313d7c42f82f16e8920bfd730665de2d11c0c37a74b5/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b", size = 2139017, upload_time = "2025-11-04T13:42:59.471Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e6/b0/1a2aa41e3b5a4ba11420aba2d091b2d17959c8d1519ece3627c371951e73/pydantic_core-2.41.5-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b5819cd790dbf0c5eb9f82c73c16b39a65dd6dd4d1439dcdea7816ec9adddab8", size = 2103351, upload_time = "2025-11-04T13:43:02.058Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a4/ee/31b1f0020baaf6d091c87900ae05c6aeae101fa4e188e1613c80e4f1ea31/pydantic_core-2.41.5-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:5a4e67afbc95fa5c34cf27d9089bca7fcab4e51e57278d710320a70b956d1b9a", size = 1925363, upload_time = "2025-11-04T13:43:05.159Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e1/89/ab8e86208467e467a80deaca4e434adac37b10a9d134cd2f99b28a01e483/pydantic_core-2.41.5-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ece5c59f0ce7d001e017643d8d24da587ea1f74f6993467d85ae8a5ef9d4f42b", size = 2135615, upload_time = "2025-11-04T13:43:08.116Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/99/0a/99a53d06dd0348b2008f2f30884b34719c323f16c3be4e6cc1203b74a91d/pydantic_core-2.41.5-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:16f80f7abe3351f8ea6858914ddc8c77e02578544a0ebc15b4c2e1a0e813b0b2", size = 2175369, upload_time = "2025-11-04T13:43:12.49Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6d/94/30ca3b73c6d485b9bb0bc66e611cff4a7138ff9736b7e66bcf0852151636/pydantic_core-2.41.5-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:33cb885e759a705b426baada1fe68cbb0a2e68e34c5d0d0289a364cf01709093", size = 2144218, upload_time = "2025-11-04T13:43:15.431Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/87/57/31b4f8e12680b739a91f472b5671294236b82586889ef764b5fbc6669238/pydantic_core-2.41.5-pp310-pypy310_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:c8d8b4eb992936023be7dee581270af5c6e0697a8559895f527f5b7105ecd36a", size = 2329951, upload_time = "2025-11-04T13:43:18.062Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/7d/73/3c2c8edef77b8f7310e6fb012dbc4b8551386ed575b9eb6fb2506e28a7eb/pydantic_core-2.41.5-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:242a206cd0318f95cd21bdacff3fcc3aab23e79bba5cac3db5a841c9ef9c6963", size = 2318428, upload_time = "2025-11-04T13:43:20.679Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2f/02/8559b1f26ee0d502c74f9cca5c0d2fd97e967e083e006bbbb4e97f3a043a/pydantic_core-2.41.5-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:d3a978c4f57a597908b7e697229d996d77a6d3c94901e9edee593adada95ce1a", size = 2147009, upload_time = "2025-11-04T13:43:23.286Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5f/9b/1b3f0e9f9305839d7e84912f9e8bfbd191ed1b1ef48083609f0dabde978c/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b2379fa7ed44ddecb5bfe4e48577d752db9fc10be00a6b7446e9663ba143de26", size = 2101980, upload_time = "2025-11-04T13:43:25.97Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a4/ed/d71fefcb4263df0da6a85b5d8a7508360f2f2e9b3bf5814be9c8bccdccc1/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:266fb4cbf5e3cbd0b53669a6d1b039c45e3ce651fd5442eff4d07c2cc8d66808", size = 1923865, upload_time = "2025-11-04T13:43:28.763Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ce/3a/626b38db460d675f873e4444b4bb030453bbe7b4ba55df821d026a0493c4/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58133647260ea01e4d0500089a8c4f07bd7aa6ce109682b1426394988d8aaacc", size = 2134256, upload_time = "2025-11-04T13:43:31.71Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/83/d9/8412d7f06f616bbc053d30cb4e5f76786af3221462ad5eee1f202021eb4e/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:287dad91cfb551c363dc62899a80e9e14da1f0e2b6ebde82c806612ca2a13ef1", size = 2174762, upload_time = "2025-11-04T13:43:34.744Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/55/4c/162d906b8e3ba3a99354e20faa1b49a85206c47de97a639510a0e673f5da/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:03b77d184b9eb40240ae9fd676ca364ce1085f203e1b1256f8ab9984dca80a84", size = 2143141, upload_time = "2025-11-04T13:43:37.701Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/1f/f2/f11dd73284122713f5f89fc940f370d035fa8e1e078d446b3313955157fe/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:a668ce24de96165bb239160b3d854943128f4334822900534f2fe947930e5770", size = 2330317, upload_time = "2025-11-04T13:43:40.406Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/88/9d/b06ca6acfe4abb296110fb1273a4d848a0bfb2ff65f3ee92127b3244e16b/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f14f8f046c14563f8eb3f45f499cc658ab8d10072961e07225e507adb700e93f", size = 2316992, upload_time = "2025-11-04T13:43:43.602Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/36/c7/cfc8e811f061c841d7990b0201912c3556bfeb99cdcb7ed24adc8d6f8704/pydantic_core-2.41.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:56121965f7a4dc965bff783d70b907ddf3d57f6eba29b6d2e5dabfaf07799c51", size = 2145302, upload_time = "2025-11-04T13:43:46.64Z" }, +] + +[[package]] +name = "pygments" +version = "2.19.2" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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 = "pyparsing" +version = "3.2.5" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f2/a5/181488fc2b9d093e3972d2a472855aae8a03f000592dbfce716a512b3359/pyparsing-3.2.5.tar.gz", hash = "sha256:2df8d5b7b2802ef88e8d016a2eb9c7aeaa923529cd251ed0fe4608275d4105b6", size = 1099274, upload_time = "2025-09-21T04:11:06.277Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/10/5e/1aa9a93198c6b64513c9d7752de7422c06402de6600a8767da1524f9570b/pyparsing-3.2.5-py3-none-any.whl", hash = "sha256:e38a4f02064cf41fe6593d328d0512495ad1f3d8a91c4f73fc401b3079a59a5e", size = 113890, upload_time = "2025-09-21T04:11:04.117Z" }, +] + +[[package]] +name = "pypinyin" +version = "0.55.0" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b4/a4/784cf98c09e0dc22776b0d7d8a4a5b761218bcae4608c2416ce1e167c8af/pypinyin-0.55.0.tar.gz", hash = "sha256:b5711b3a0c6f76e67408ec6b2e3c4987a3a806b7c528076e7c7b86fcf0eaa66b", size = 839836, upload_time = "2025-07-20T12:01:50.657Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b9/7b/4cabc76fcc21c3c7d5c671d8783984d30ac9d3bb387c4ba784fca3cdfa3a/pypinyin-0.55.0-py2.py3-none-any.whl", hash = "sha256:d53b1e8ad2cdb815fb2cb604ed3123372f5a28c6f447571244aca36fc62a286f", size = 840203, upload_time = "2025-07-20T12:01:48.535Z" }, +] + +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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.2.1" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f0/26/19cadc79a718c5edbec86fd4919a6b6d3f681039a2f6d66d14be94e75fb9/python_dotenv-1.2.1.tar.gz", hash = "sha256:42667e897e16ab0d66954af0e60a9caa94f0fd4ecf3aaf6d2d260eec1aa36ad6", size = 44221, upload_time = "2025-10-26T15:12:10.434Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/14/1b/a298b06749107c305e1fe0f814c6c74aea7b2f1e10989cb30f544a1b3253/python_dotenv-1.2.1-py3-none-any.whl", hash = "sha256:b81ee9561e9ca4004139c6cbba3a238c32b03e4894671e181b671e8cb8425d61", size = 21230, upload_time = "2025-10-26T15:12:09.109Z" }, +] + +[[package]] +name = "python-multipart" +version = "0.0.20" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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 = "requests" +version = "2.32.5" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +dependencies = [ + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3" }, +] +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c9/74/b3ff8e6c8446842c3f5c837e9c3dfcfe2018ea6ecef224c710c85ef728f4/requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf", size = 134517, upload_time = "2025-08-18T20:46:02.573Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/1e/db/4254e3eabe8020b458f1a747140d32277ec7a271daf1d235b70dc0b4e6e3/requests-2.32.5-py3-none-any.whl", hash = "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6", size = 64738, upload_time = "2025-08-18T20:46:00.542Z" }, +] + +[[package]] +name = "rich" +version = "14.2.0" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +dependencies = [ + { name = "markdown-it-py" }, + { name = "pygments" }, +] +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fb/d2/8920e102050a0de7bfabeb4c4614a49248cf8d5d7a8d01885fbb24dc767a/rich-14.2.0.tar.gz", hash = "sha256:73ff50c7c0c1c77c8243079283f4edb376f0f6442433aecb8ce7e6d0b92d1fe4", size = 219990, upload_time = "2025-10-09T14:16:53.064Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/25/7a/b0178788f8dc6cafce37a212c99565fa1fe7872c70c6c9c1e1a372d9d88f/rich-14.2.0-py3-none-any.whl", hash = "sha256:76bc51fe2e57d2b1be1f96c524b890b816e334ab4c1e45888799bfaab0021edd", size = 243393, upload_time = "2025-10-09T14:16:51.245Z" }, +] + +[[package]] +name = "rsa" +version = "4.9.1" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +dependencies = [ + { name = "pyasn1" }, +] +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/da/8a/22b7beea3ee0d44b1916c0c1cb0ee3af23b700b6da9f04991899d0c555d4/rsa-4.9.1.tar.gz", hash = "sha256:e7bdbfdb5497da4c07dfd35530e1a902659db6ff241e39d9953cad06ebd0ae75", size = 29034, upload_time = "2025-04-16T09:51:18.218Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/64/8d/0133e4eb4beed9e425d9a98ed6e081a55d195481b7632472be1af08d2f6b/rsa-4.9.1-py3-none-any.whl", hash = "sha256:68635866661c6836b8d39430f97a996acbd61bfa49406748ea243539fe239762", size = 34696, upload_time = "2025-04-16T09:51:17.142Z" }, +] + +[[package]] +name = "ruff" +version = "0.14.8" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ed/d9/f7a0c4b3a2bf2556cd5d99b05372c29980249ef71e8e32669ba77428c82c/ruff-0.14.8.tar.gz", hash = "sha256:774ed0dd87d6ce925e3b8496feb3a00ac564bea52b9feb551ecd17e0a23d1eed", size = 5765385, upload_time = "2025-12-04T15:06:17.669Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/48/b8/9537b52010134b1d2b72870cc3f92d5fb759394094741b09ceccae183fbe/ruff-0.14.8-py3-none-linux_armv6l.whl", hash = "sha256:ec071e9c82eca417f6111fd39f7043acb53cd3fde9b1f95bbed745962e345afb", size = 13441540, upload_time = "2025-12-04T15:06:14.896Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/24/00/99031684efb025829713682012b6dd37279b1f695ed1b01725f85fd94b38/ruff-0.14.8-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:8cdb162a7159f4ca36ce980a18c43d8f036966e7f73f866ac8f493b75e0c27e9", size = 13669384, upload_time = "2025-12-04T15:06:51.809Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/72/64/3eb5949169fc19c50c04f28ece2c189d3b6edd57e5b533649dae6ca484fe/ruff-0.14.8-py3-none-macosx_11_0_arm64.whl", hash = "sha256:2e2fcbefe91f9fad0916850edf0854530c15bd1926b6b779de47e9ab619ea38f", size = 12806917, upload_time = "2025-12-04T15:06:08.925Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c4/08/5250babb0b1b11910f470370ec0cbc67470231f7cdc033cee57d4976f941/ruff-0.14.8-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a9d70721066a296f45786ec31916dc287b44040f553da21564de0ab4d45a869b", size = 13256112, upload_time = "2025-12-04T15:06:23.498Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/78/4c/6c588e97a8e8c2d4b522c31a579e1df2b4d003eddfbe23d1f262b1a431ff/ruff-0.14.8-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2c87e09b3cd9d126fc67a9ecd3b5b1d3ded2b9c7fce3f16e315346b9d05cfb52", size = 13227559, upload_time = "2025-12-04T15:06:33.432Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/23/ce/5f78cea13eda8eceac71b5f6fa6e9223df9b87bb2c1891c166d1f0dce9f1/ruff-0.14.8-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1d62cb310c4fbcb9ee4ac023fe17f984ae1e12b8a4a02e3d21489f9a2a5f730c", size = 13896379, upload_time = "2025-12-04T15:06:02.687Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/cf/79/13de4517c4dadce9218a20035b21212a4c180e009507731f0d3b3f5df85a/ruff-0.14.8-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:1af35c2d62633d4da0521178e8a2641c636d2a7153da0bac1b30cfd4ccd91344", size = 15372786, upload_time = "2025-12-04T15:06:29.828Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/00/06/33df72b3bb42be8a1c3815fd4fae83fa2945fc725a25d87ba3e42d1cc108/ruff-0.14.8-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:25add4575ffecc53d60eed3f24b1e934493631b48ebbc6ebaf9d8517924aca4b", size = 14990029, upload_time = "2025-12-04T15:06:36.812Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/64/61/0f34927bd90925880394de0e081ce1afab66d7b3525336f5771dcf0cb46c/ruff-0.14.8-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4c943d847b7f02f7db4201a0600ea7d244d8a404fbb639b439e987edcf2baf9a", size = 14407037, upload_time = "2025-12-04T15:06:39.979Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/96/bc/058fe0aefc0fbf0d19614cb6d1a3e2c048f7dc77ca64957f33b12cfdc5ef/ruff-0.14.8-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cb6e8bf7b4f627548daa1b69283dac5a296bfe9ce856703b03130732e20ddfe2", size = 14102390, upload_time = "2025-12-04T15:06:46.372Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/af/a4/e4f77b02b804546f4c17e8b37a524c27012dd6ff05855d2243b49a7d3cb9/ruff-0.14.8-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:7aaf2974f378e6b01d1e257c6948207aec6a9b5ba53fab23d0182efb887a0e4a", size = 14230793, upload_time = "2025-12-04T15:06:20.497Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3f/52/bb8c02373f79552e8d087cedaffad76b8892033d2876c2498a2582f09dcf/ruff-0.14.8-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:e5758ca513c43ad8a4ef13f0f081f80f08008f410790f3611a21a92421ab045b", size = 13160039, upload_time = "2025-12-04T15:06:49.06Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/1f/ad/b69d6962e477842e25c0b11622548df746290cc6d76f9e0f4ed7456c2c31/ruff-0.14.8-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:f74f7ba163b6e85a8d81a590363bf71618847e5078d90827749bfda1d88c9cdf", size = 13205158, upload_time = "2025-12-04T15:06:54.574Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/06/63/54f23da1315c0b3dfc1bc03fbc34e10378918a20c0b0f086418734e57e74/ruff-0.14.8-py3-none-musllinux_1_2_i686.whl", hash = "sha256:eed28f6fafcc9591994c42254f5a5c5ca40e69a30721d2ab18bb0bb3baac3ab6", size = 13469550, upload_time = "2025-12-04T15:05:59.209Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/70/7d/a4d7b1961e4903bc37fffb7ddcfaa7beb250f67d97cfd1ee1d5cddb1ec90/ruff-0.14.8-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:21d48fa744c9d1cb8d71eb0a740c4dd02751a5de9db9a730a8ef75ca34cf138e", size = 14211332, upload_time = "2025-12-04T15:06:06.027Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5d/93/2a5063341fa17054e5c86582136e9895db773e3c2ffb770dde50a09f35f0/ruff-0.14.8-py3-none-win32.whl", hash = "sha256:15f04cb45c051159baebb0f0037f404f1dc2f15a927418f29730f411a79bc4e7", size = 13151890, upload_time = "2025-12-04T15:06:11.668Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/02/1c/65c61a0859c0add13a3e1cbb6024b42de587456a43006ca2d4fd3d1618fe/ruff-0.14.8-py3-none-win_amd64.whl", hash = "sha256:9eeb0b24242b5bbff3011409a739929f497f3fb5fe3b5698aba5e77e8c833097", size = 14537826, upload_time = "2025-12-04T15:06:26.409Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6d/63/8b41cea3afd7f58eb64ac9251668ee0073789a3bc9ac6f816c8c6fef986d/ruff-0.14.8-py3-none-win_arm64.whl", hash = "sha256:965a582c93c63fe715fd3e3f8aa37c4b776777203d8e1d8aa3cc0c14424a4b99", size = 13634522, upload_time = "2025-12-04T15:06:43.212Z" }, +] + +[[package]] +name = "setuptools" +version = "80.9.0" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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.50.0" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +dependencies = [ + { name = "anyio" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ba/b8/73a0e6a6e079a9d9cfa64113d771e421640b6f679a52eeb9b32f72d871a1/starlette-0.50.0.tar.gz", hash = "sha256:a2a17b22203254bcbc2e1f926d2d55f3f9497f769416b3190768befe598fa3ca", size = 2646985, upload_time = "2025-11-01T15:25:27.516Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d9/52/1064f510b141bd54025f9b55105e26d1fa970b9be67ad766380a3c9b74b0/starlette-0.50.0-py3-none-any.whl", hash = "sha256:9e5391843ec9b6e472eed1365a78c8098cfceb7a74bfd4d6b1c0c0095efb3bca", size = 74033, upload_time = "2025-11-01T15:25:25.461Z" }, +] + +[[package]] +name = "structlog" +version = "25.5.0" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +dependencies = [ + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ef/52/9ba0f43b686e7f3ddfeaa78ac3af750292662284b3661e91ad5494f21dbc/structlog-25.5.0.tar.gz", hash = "sha256:098522a3bebed9153d4570c6d0288abf80a031dfdb2048d59a49e9dc2190fc98", size = 1460830, upload_time = "2025-10-27T08:28:23.028Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a8/45/a132b9074aa18e799b891b91ad72133c98d8042c70f6240e4c5f9dabee2f/structlog-25.5.0-py3-none-any.whl", hash = "sha256:a8453e9b9e636ec59bd9e79bbd4a72f025981b3ba0f5837aebf48f02f37a7f9f", size = 72510, upload_time = "2025-10-27T08:28:21.535Z" }, +] + +[[package]] +name = "tenacity" +version = "9.1.2" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0a/d4/2b0cd0fe285e14b36db076e78c93766ff1d529d70408bd1d2a5a84f1d929/tenacity-9.1.2.tar.gz", hash = "sha256:1169d376c297e7de388d18b4481760d478b0e99a777cad3a9c86e556f4b697cb", size = 48036, upload_time = "2025-04-02T08:25:09.966Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e5/30/643397144bfbfec6f6ef821f36f33e57d35946c44a2352d3c9f0ae847619/tenacity-9.1.2-py3-none-any.whl", hash = "sha256:f77bf36710d8b73a50b2dd155c97b870017ad21afe6ab300326b0371b3b05138", size = 28248, upload_time = "2025-04-02T08:25:07.678Z" }, +] + +[[package]] +name = "toml" +version = "0.10.2" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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 = "tomlkit" +version = "0.13.3" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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.tuna.tsinghua.edu.cn/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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.15.0" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload_time = "2025-08-25T13:49:26.313Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload_time = "2025-08-25T13:49:24.86Z" }, +] + +[[package]] +name = "typing-inspection" +version = "0.4.2" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload_time = "2025-10-01T02:14:41.687Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload_time = "2025-10-01T02:14:40.154Z" }, +] + +[[package]] +name = "tzdata" +version = "2025.2" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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 = "urllib3" +version = "2.6.0" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/1c/43/554c2569b62f49350597348fc3ac70f786e3c32e7f19d266e19817812dd3/urllib3-2.6.0.tar.gz", hash = "sha256:cb9bcef5a4b345d5da5d145dc3e30834f58e8018828cbc724d30b4cb7d4d49f1", size = 432585, upload_time = "2025-12-05T15:08:47.885Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/56/1a/9ffe814d317c5224166b23e7c47f606d6e473712a2fad0f704ea9b99f246/urllib3-2.6.0-py3-none-any.whl", hash = "sha256:c90f7a39f716c572c4e3e58509581ebd83f9b59cced005b7db7ad2d22b0db99f", size = 131083, upload_time = "2025-12-05T15:08:45.983Z" }, +] + +[[package]] +name = "uvicorn" +version = "0.38.0" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +dependencies = [ + { name = "click" }, + { name = "h11" }, + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/cb/ce/f06b84e2697fef4688ca63bdb2fdf113ca0a3be33f94488f2cadb690b0cf/uvicorn-0.38.0.tar.gz", hash = "sha256:fd97093bdd120a2609fc0d3afe931d4d4ad688b6e75f0f929fde1bc36fe0e91d", size = 80605, upload_time = "2025-10-18T13:46:44.63Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ee/d9/d88e73ca598f4f6ff671fb5fde8a32925c2e08a637303a1d12883c7305fa/uvicorn-0.38.0-py3-none-any.whl", hash = "sha256:48c0afd214ceb59340075b4a052ea1ee91c16fbc2a9b1469cca0e54566977b02", size = 68109, upload_time = "2025-10-18T13:46:42.958Z" }, +] + +[[package]] +name = "websockets" +version = "15.0.1" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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.22.0" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +dependencies = [ + { name = "idna" }, + { name = "multidict" }, + { name = "propcache" }, +] +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/57/63/0c6ebca57330cd313f6102b16dd57ffaf3ec4c83403dcb45dbd15c6f3ea1/yarl-1.22.0.tar.gz", hash = "sha256:bebf8557577d4401ba8bd9ff33906f1376c877aa78d1fe216ad01b4d6745af71", size = 187169, upload_time = "2025-10-06T14:12:55.963Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d1/43/a2204825342f37c337f5edb6637040fa14e365b2fcc2346960201d457579/yarl-1.22.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:c7bd6683587567e5a49ee6e336e0612bec8329be1b7d4c8af5687dcdeb67ee1e", size = 140517, upload_time = "2025-10-06T14:08:42.494Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/44/6f/674f3e6f02266428c56f704cd2501c22f78e8b2eeb23f153117cc86fb28a/yarl-1.22.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:5cdac20da754f3a723cceea5b3448e1a2074866406adeb4ef35b469d089adb8f", size = 93495, upload_time = "2025-10-06T14:08:46.2Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b8/12/5b274d8a0f30c07b91b2f02cba69152600b47830fcfb465c108880fcee9c/yarl-1.22.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:07a524d84df0c10f41e3ee918846e1974aba4ec017f990dc735aad487a0bdfdf", size = 94400, upload_time = "2025-10-06T14:08:47.855Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e2/7f/df1b6949b1fa1aa9ff6de6e2631876ad4b73c4437822026e85d8acb56bb1/yarl-1.22.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e1b329cb8146d7b736677a2440e422eadd775d1806a81db2d4cded80a48efc1a", size = 347545, upload_time = "2025-10-06T14:08:49.683Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/84/09/f92ed93bd6cd77872ab6c3462df45ca45cd058d8f1d0c9b4f54c1704429f/yarl-1.22.0-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:75976c6945d85dbb9ee6308cd7ff7b1fb9409380c82d6119bd778d8fcfe2931c", size = 319598, upload_time = "2025-10-06T14:08:51.215Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c3/97/ac3f3feae7d522cf7ccec3d340bb0b2b61c56cb9767923df62a135092c6b/yarl-1.22.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:80ddf7a5f8c86cb3eb4bc9028b07bbbf1f08a96c5c0bc1244be5e8fefcb94147", size = 363893, upload_time = "2025-10-06T14:08:53.144Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/06/49/f3219097403b9c84a4d079b1d7bda62dd9b86d0d6e4428c02d46ab2c77fc/yarl-1.22.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d332fc2e3c94dad927f2112395772a4e4fedbcf8f80efc21ed7cdfae4d574fdb", size = 371240, upload_time = "2025-10-06T14:08:55.036Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/35/9f/06b765d45c0e44e8ecf0fe15c9eacbbde342bb5b7561c46944f107bfb6c3/yarl-1.22.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0cf71bf877efeac18b38d3930594c0948c82b64547c1cf420ba48722fe5509f6", size = 346965, upload_time = "2025-10-06T14:08:56.722Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c5/69/599e7cea8d0fcb1694323b0db0dda317fa3162f7b90166faddecf532166f/yarl-1.22.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:663e1cadaddae26be034a6ab6072449a8426ddb03d500f43daf952b74553bba0", size = 342026, upload_time = "2025-10-06T14:08:58.563Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/95/6f/9dfd12c8bc90fea9eab39832ee32ea48f8e53d1256252a77b710c065c89f/yarl-1.22.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:6dcbb0829c671f305be48a7227918cfcd11276c2d637a8033a99a02b67bf9eda", size = 335637, upload_time = "2025-10-06T14:09:00.506Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/57/2e/34c5b4eb9b07e16e873db5b182c71e5f06f9b5af388cdaa97736d79dd9a6/yarl-1.22.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:f0d97c18dfd9a9af4490631905a3f131a8e4c9e80a39353919e2cfed8f00aedc", size = 359082, upload_time = "2025-10-06T14:09:01.936Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/31/71/fa7e10fb772d273aa1f096ecb8ab8594117822f683bab7d2c5a89914c92a/yarl-1.22.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:437840083abe022c978470b942ff832c3940b2ad3734d424b7eaffcd07f76737", size = 357811, upload_time = "2025-10-06T14:09:03.445Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/26/da/11374c04e8e1184a6a03cf9c8f5688d3e5cec83ed6f31ad3481b3207f709/yarl-1.22.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:a899cbd98dce6f5d8de1aad31cb712ec0a530abc0a86bd6edaa47c1090138467", size = 351223, upload_time = "2025-10-06T14:09:05.401Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/82/8f/e2d01f161b0c034a30410e375e191a5d27608c1f8693bab1a08b089ca096/yarl-1.22.0-cp310-cp310-win32.whl", hash = "sha256:595697f68bd1f0c1c159fcb97b661fc9c3f5db46498043555d04805430e79bea", size = 82118, upload_time = "2025-10-06T14:09:11.148Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/62/46/94c76196642dbeae634c7a61ba3da88cd77bed875bf6e4a8bed037505aa6/yarl-1.22.0-cp310-cp310-win_amd64.whl", hash = "sha256:cb95a9b1adaa48e41815a55ae740cfda005758104049a640a398120bf02515ca", size = 86852, upload_time = "2025-10-06T14:09:12.958Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/af/af/7df4f179d3b1a6dcb9a4bd2ffbc67642746fcafdb62580e66876ce83fff4/yarl-1.22.0-cp310-cp310-win_arm64.whl", hash = "sha256:b85b982afde6df99ecc996990d4ad7ccbdbb70e2a4ba4de0aecde5922ba98a0b", size = 82012, upload_time = "2025-10-06T14:09:14.664Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/4d/27/5ab13fc84c76a0250afd3d26d5936349a35be56ce5785447d6c423b26d92/yarl-1.22.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:1ab72135b1f2db3fed3997d7e7dc1b80573c67138023852b6efb336a5eae6511", size = 141607, upload_time = "2025-10-06T14:09:16.298Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6a/a1/d065d51d02dc02ce81501d476b9ed2229d9a990818332242a882d5d60340/yarl-1.22.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:669930400e375570189492dc8d8341301578e8493aec04aebc20d4717f899dd6", size = 94027, upload_time = "2025-10-06T14:09:17.786Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c1/da/8da9f6a53f67b5106ffe902c6fa0164e10398d4e150d85838b82f424072a/yarl-1.22.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:792a2af6d58177ef7c19cbf0097aba92ca1b9cb3ffdd9c7470e156c8f9b5e028", size = 94963, upload_time = "2025-10-06T14:09:19.662Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/68/fe/2c1f674960c376e29cb0bec1249b117d11738db92a6ccc4a530b972648db/yarl-1.22.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3ea66b1c11c9150f1372f69afb6b8116f2dd7286f38e14ea71a44eee9ec51b9d", size = 368406, upload_time = "2025-10-06T14:09:21.402Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/95/26/812a540e1c3c6418fec60e9bbd38e871eaba9545e94fa5eff8f4a8e28e1e/yarl-1.22.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3e2daa88dc91870215961e96a039ec73e4937da13cf77ce17f9cad0c18df3503", size = 336581, upload_time = "2025-10-06T14:09:22.98Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0b/f5/5777b19e26fdf98563985e481f8be3d8a39f8734147a6ebf459d0dab5a6b/yarl-1.22.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ba440ae430c00eee41509353628600212112cd5018d5def7e9b05ea7ac34eb65", size = 388924, upload_time = "2025-10-06T14:09:24.655Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/86/08/24bd2477bd59c0bbd994fe1d93b126e0472e4e3df5a96a277b0a55309e89/yarl-1.22.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e6438cc8f23a9c1478633d216b16104a586b9761db62bfacb6425bac0a36679e", size = 392890, upload_time = "2025-10-06T14:09:26.617Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/46/00/71b90ed48e895667ecfb1eaab27c1523ee2fa217433ed77a73b13205ca4b/yarl-1.22.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4c52a6e78aef5cf47a98ef8e934755abf53953379b7d53e68b15ff4420e6683d", size = 365819, upload_time = "2025-10-06T14:09:28.544Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/30/2d/f715501cae832651d3282387c6a9236cd26bd00d0ff1e404b3dc52447884/yarl-1.22.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:3b06bcadaac49c70f4c88af4ffcfbe3dc155aab3163e75777818092478bcbbe7", size = 363601, upload_time = "2025-10-06T14:09:30.568Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f8/f9/a678c992d78e394e7126ee0b0e4e71bd2775e4334d00a9278c06a6cce96a/yarl-1.22.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:6944b2dc72c4d7f7052683487e3677456050ff77fcf5e6204e98caf785ad1967", size = 358072, upload_time = "2025-10-06T14:09:32.528Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2c/d1/b49454411a60edb6fefdcad4f8e6dbba7d8019e3a508a1c5836cba6d0781/yarl-1.22.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:d5372ca1df0f91a86b047d1277c2aaf1edb32d78bbcefffc81b40ffd18f027ed", size = 385311, upload_time = "2025-10-06T14:09:34.634Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/87/e5/40d7a94debb8448c7771a916d1861d6609dddf7958dc381117e7ba36d9e8/yarl-1.22.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:51af598701f5299012b8416486b40fceef8c26fc87dc6d7d1f6fc30609ea0aa6", size = 381094, upload_time = "2025-10-06T14:09:36.268Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/35/d8/611cc282502381ad855448643e1ad0538957fc82ae83dfe7762c14069e14/yarl-1.22.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b266bd01fedeffeeac01a79ae181719ff848a5a13ce10075adbefc8f1daee70e", size = 370944, upload_time = "2025-10-06T14:09:37.872Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2d/df/fadd00fb1c90e1a5a8bd731fa3d3de2e165e5a3666a095b04e31b04d9cb6/yarl-1.22.0-cp311-cp311-win32.whl", hash = "sha256:a9b1ba5610a4e20f655258d5a1fdc7ebe3d837bb0e45b581398b99eb98b1f5ca", size = 81804, upload_time = "2025-10-06T14:09:39.359Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b5/f7/149bb6f45f267cb5c074ac40c01c6b3ea6d8a620d34b337f6321928a1b4d/yarl-1.22.0-cp311-cp311-win_amd64.whl", hash = "sha256:078278b9b0b11568937d9509b589ee83ef98ed6d561dfe2020e24a9fd08eaa2b", size = 86858, upload_time = "2025-10-06T14:09:41.068Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2b/13/88b78b93ad3f2f0b78e13bfaaa24d11cbc746e93fe76d8c06bf139615646/yarl-1.22.0-cp311-cp311-win_arm64.whl", hash = "sha256:b6a6f620cfe13ccec221fa312139135166e47ae169f8253f72a0abc0dae94376", size = 81637, upload_time = "2025-10-06T14:09:42.712Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/75/ff/46736024fee3429b80a165a732e38e5d5a238721e634ab41b040d49f8738/yarl-1.22.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e340382d1afa5d32b892b3ff062436d592ec3d692aeea3bef3a5cfe11bbf8c6f", size = 142000, upload_time = "2025-10-06T14:09:44.631Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5a/9a/b312ed670df903145598914770eb12de1bac44599549b3360acc96878df8/yarl-1.22.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f1e09112a2c31ffe8d80be1b0988fa6a18c5d5cad92a9ffbb1c04c91bfe52ad2", size = 94338, upload_time = "2025-10-06T14:09:46.372Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ba/f5/0601483296f09c3c65e303d60c070a5c19fcdbc72daa061e96170785bc7d/yarl-1.22.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:939fe60db294c786f6b7c2d2e121576628468f65453d86b0fe36cb52f987bd74", size = 94909, upload_time = "2025-10-06T14:09:48.648Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/60/41/9a1fe0b73dbcefce72e46cf149b0e0a67612d60bfc90fb59c2b2efdfbd86/yarl-1.22.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e1651bf8e0398574646744c1885a41198eba53dc8a9312b954073f845c90a8df", size = 372940, upload_time = "2025-10-06T14:09:50.089Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/17/7a/795cb6dfee561961c30b800f0ed616b923a2ec6258b5def2a00bf8231334/yarl-1.22.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:b8a0588521a26bf92a57a1705b77b8b59044cdceccac7151bd8d229e66b8dedb", size = 345825, upload_time = "2025-10-06T14:09:52.142Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d7/93/a58f4d596d2be2ae7bab1a5846c4d270b894958845753b2c606d666744d3/yarl-1.22.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:42188e6a615c1a75bcaa6e150c3fe8f3e8680471a6b10150c5f7e83f47cc34d2", size = 386705, upload_time = "2025-10-06T14:09:54.128Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/61/92/682279d0e099d0e14d7fd2e176bd04f48de1484f56546a3e1313cd6c8e7c/yarl-1.22.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f6d2cb59377d99718913ad9a151030d6f83ef420a2b8f521d94609ecc106ee82", size = 396518, upload_time = "2025-10-06T14:09:55.762Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/db/0f/0d52c98b8a885aeda831224b78f3be7ec2e1aa4a62091f9f9188c3c65b56/yarl-1.22.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50678a3b71c751d58d7908edc96d332af328839eea883bb554a43f539101277a", size = 377267, upload_time = "2025-10-06T14:09:57.958Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/22/42/d2685e35908cbeaa6532c1fc73e89e7f2efb5d8a7df3959ea8e37177c5a3/yarl-1.22.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1e8fbaa7cec507aa24ea27a01456e8dd4b6fab829059b69844bd348f2d467124", size = 365797, upload_time = "2025-10-06T14:09:59.527Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a2/83/cf8c7bcc6355631762f7d8bdab920ad09b82efa6b722999dfb05afa6cfac/yarl-1.22.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:433885ab5431bc3d3d4f2f9bd15bfa1614c522b0f1405d62c4f926ccd69d04fa", size = 365535, upload_time = "2025-10-06T14:10:01.139Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/25/e1/5302ff9b28f0c59cac913b91fe3f16c59a033887e57ce9ca5d41a3a94737/yarl-1.22.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:b790b39c7e9a4192dc2e201a282109ed2985a1ddbd5ac08dc56d0e121400a8f7", size = 382324, upload_time = "2025-10-06T14:10:02.756Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/bf/cd/4617eb60f032f19ae3a688dc990d8f0d89ee0ea378b61cac81ede3e52fae/yarl-1.22.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:31f0b53913220599446872d757257be5898019c85e7971599065bc55065dc99d", size = 383803, upload_time = "2025-10-06T14:10:04.552Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/59/65/afc6e62bb506a319ea67b694551dab4a7e6fb7bf604e9bd9f3e11d575fec/yarl-1.22.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a49370e8f711daec68d09b821a34e1167792ee2d24d405cbc2387be4f158b520", size = 374220, upload_time = "2025-10-06T14:10:06.489Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e7/3d/68bf18d50dc674b942daec86a9ba922d3113d8399b0e52b9897530442da2/yarl-1.22.0-cp312-cp312-win32.whl", hash = "sha256:70dfd4f241c04bd9239d53b17f11e6ab672b9f1420364af63e8531198e3f5fe8", size = 81589, upload_time = "2025-10-06T14:10:09.254Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c8/9a/6ad1a9b37c2f72874f93e691b2e7ecb6137fb2b899983125db4204e47575/yarl-1.22.0-cp312-cp312-win_amd64.whl", hash = "sha256:8884d8b332a5e9b88e23f60bb166890009429391864c685e17bd73a9eda9105c", size = 87213, upload_time = "2025-10-06T14:10:11.369Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/44/c5/c21b562d1680a77634d748e30c653c3ca918beb35555cff24986fff54598/yarl-1.22.0-cp312-cp312-win_arm64.whl", hash = "sha256:ea70f61a47f3cc93bdf8b2f368ed359ef02a01ca6393916bc8ff877427181e74", size = 81330, upload_time = "2025-10-06T14:10:13.112Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ea/f3/d67de7260456ee105dc1d162d43a019ecad6b91e2f51809d6cddaa56690e/yarl-1.22.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8dee9c25c74997f6a750cd317b8ca63545169c098faee42c84aa5e506c819b53", size = 139980, upload_time = "2025-10-06T14:10:14.601Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/01/88/04d98af0b47e0ef42597b9b28863b9060bb515524da0a65d5f4db160b2d5/yarl-1.22.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:01e73b85a5434f89fc4fe27dcda2aff08ddf35e4d47bbbea3bdcd25321af538a", size = 93424, upload_time = "2025-10-06T14:10:16.115Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/18/91/3274b215fd8442a03975ce6bee5fe6aa57a8326b29b9d3d56234a1dca244/yarl-1.22.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:22965c2af250d20c873cdbee8ff958fb809940aeb2e74ba5f20aaf6b7ac8c70c", size = 93821, upload_time = "2025-10-06T14:10:17.993Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/61/3a/caf4e25036db0f2da4ca22a353dfeb3c9d3c95d2761ebe9b14df8fc16eb0/yarl-1.22.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b4f15793aa49793ec8d1c708ab7f9eded1aa72edc5174cae703651555ed1b601", size = 373243, upload_time = "2025-10-06T14:10:19.44Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6e/9e/51a77ac7516e8e7803b06e01f74e78649c24ee1021eca3d6a739cb6ea49c/yarl-1.22.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e5542339dcf2747135c5c85f68680353d5cb9ffd741c0f2e8d832d054d41f35a", size = 342361, upload_time = "2025-10-06T14:10:21.124Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d4/f8/33b92454789dde8407f156c00303e9a891f1f51a0330b0fad7c909f87692/yarl-1.22.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5c401e05ad47a75869c3ab3e35137f8468b846770587e70d71e11de797d113df", size = 387036, upload_time = "2025-10-06T14:10:22.902Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d9/9a/c5db84ea024f76838220280f732970aa4ee154015d7f5c1bfb60a267af6f/yarl-1.22.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:243dda95d901c733f5b59214d28b0120893d91777cb8aa043e6ef059d3cddfe2", size = 397671, upload_time = "2025-10-06T14:10:24.523Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/11/c9/cd8538dc2e7727095e0c1d867bad1e40c98f37763e6d995c1939f5fdc7b1/yarl-1.22.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bec03d0d388060058f5d291a813f21c011041938a441c593374da6077fe21b1b", size = 377059, upload_time = "2025-10-06T14:10:26.406Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a1/b9/ab437b261702ced75122ed78a876a6dec0a1b0f5e17a4ac7a9a2482d8abe/yarl-1.22.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:b0748275abb8c1e1e09301ee3cf90c8a99678a4e92e4373705f2a2570d581273", size = 365356, upload_time = "2025-10-06T14:10:28.461Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b2/9d/8e1ae6d1d008a9567877b08f0ce4077a29974c04c062dabdb923ed98e6fe/yarl-1.22.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:47fdb18187e2a4e18fda2c25c05d8251a9e4a521edaed757fef033e7d8498d9a", size = 361331, upload_time = "2025-10-06T14:10:30.541Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ca/5a/09b7be3905962f145b73beb468cdd53db8aa171cf18c80400a54c5b82846/yarl-1.22.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:c7044802eec4524fde550afc28edda0dd5784c4c45f0be151a2d3ba017daca7d", size = 382590, upload_time = "2025-10-06T14:10:33.352Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/aa/7f/59ec509abf90eda5048b0bc3e2d7b5099dffdb3e6b127019895ab9d5ef44/yarl-1.22.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:139718f35149ff544caba20fce6e8a2f71f1e39b92c700d8438a0b1d2a631a02", size = 385316, upload_time = "2025-10-06T14:10:35.034Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e5/84/891158426bc8036bfdfd862fabd0e0fa25df4176ec793e447f4b85cf1be4/yarl-1.22.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e1b51bebd221006d3d2f95fbe124b22b247136647ae5dcc8c7acafba66e5ee67", size = 374431, upload_time = "2025-10-06T14:10:37.76Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/bb/49/03da1580665baa8bef5e8ed34c6df2c2aca0a2f28bf397ed238cc1bbc6f2/yarl-1.22.0-cp313-cp313-win32.whl", hash = "sha256:d3e32536234a95f513bd374e93d717cf6b2231a791758de6c509e3653f234c95", size = 81555, upload_time = "2025-10-06T14:10:39.649Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/9a/ee/450914ae11b419eadd067c6183ae08381cfdfcb9798b90b2b713bbebddda/yarl-1.22.0-cp313-cp313-win_amd64.whl", hash = "sha256:47743b82b76d89a1d20b83e60d5c20314cbd5ba2befc9cda8f28300c4a08ed4d", size = 86965, upload_time = "2025-10-06T14:10:41.313Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/98/4d/264a01eae03b6cf629ad69bae94e3b0e5344741e929073678e84bf7a3e3b/yarl-1.22.0-cp313-cp313-win_arm64.whl", hash = "sha256:5d0fcda9608875f7d052eff120c7a5da474a6796fe4d83e152e0e4d42f6d1a9b", size = 81205, upload_time = "2025-10-06T14:10:43.167Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/88/fc/6908f062a2f77b5f9f6d69cecb1747260831ff206adcbc5b510aff88df91/yarl-1.22.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:719ae08b6972befcba4310e49edb1161a88cdd331e3a694b84466bd938a6ab10", size = 146209, upload_time = "2025-10-06T14:10:44.643Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/65/47/76594ae8eab26210b4867be6f49129861ad33da1f1ebdf7051e98492bf62/yarl-1.22.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:47d8a5c446df1c4db9d21b49619ffdba90e77c89ec6e283f453856c74b50b9e3", size = 95966, upload_time = "2025-10-06T14:10:46.554Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ab/ce/05e9828a49271ba6b5b038b15b3934e996980dd78abdfeb52a04cfb9467e/yarl-1.22.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:cfebc0ac8333520d2d0423cbbe43ae43c8838862ddb898f5ca68565e395516e9", size = 97312, upload_time = "2025-10-06T14:10:48.007Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d1/c5/7dffad5e4f2265b29c9d7ec869c369e4223166e4f9206fc2243ee9eea727/yarl-1.22.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4398557cbf484207df000309235979c79c4356518fd5c99158c7d38203c4da4f", size = 361967, upload_time = "2025-10-06T14:10:49.997Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/50/b2/375b933c93a54bff7fc041e1a6ad2c0f6f733ffb0c6e642ce56ee3b39970/yarl-1.22.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2ca6fd72a8cd803be290d42f2dec5cdcd5299eeb93c2d929bf060ad9efaf5de0", size = 323949, upload_time = "2025-10-06T14:10:52.004Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/66/50/bfc2a29a1d78644c5a7220ce2f304f38248dc94124a326794e677634b6cf/yarl-1.22.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ca1f59c4e1ab6e72f0a23c13fca5430f889634166be85dbf1013683e49e3278e", size = 361818, upload_time = "2025-10-06T14:10:54.078Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/46/96/f3941a46af7d5d0f0498f86d71275696800ddcdd20426298e572b19b91ff/yarl-1.22.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6c5010a52015e7c70f86eb967db0f37f3c8bd503a695a49f8d45700144667708", size = 372626, upload_time = "2025-10-06T14:10:55.767Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c1/42/8b27c83bb875cd89448e42cd627e0fb971fa1675c9ec546393d18826cb50/yarl-1.22.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d7672ecf7557476642c88497c2f8d8542f8e36596e928e9bcba0e42e1e7d71f", size = 341129, upload_time = "2025-10-06T14:10:57.985Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/49/36/99ca3122201b382a3cf7cc937b95235b0ac944f7e9f2d5331d50821ed352/yarl-1.22.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:3b7c88eeef021579d600e50363e0b6ee4f7f6f728cd3486b9d0f3ee7b946398d", size = 346776, upload_time = "2025-10-06T14:10:59.633Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/85/b4/47328bf996acd01a4c16ef9dcd2f59c969f495073616586f78cd5f2efb99/yarl-1.22.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:f4afb5c34f2c6fecdcc182dfcfc6af6cccf1aa923eed4d6a12e9d96904e1a0d8", size = 334879, upload_time = "2025-10-06T14:11:01.454Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c2/ad/b77d7b3f14a4283bffb8e92c6026496f6de49751c2f97d4352242bba3990/yarl-1.22.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:59c189e3e99a59cf8d83cbb31d4db02d66cda5a1a4374e8a012b51255341abf5", size = 350996, upload_time = "2025-10-06T14:11:03.452Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/81/c8/06e1d69295792ba54d556f06686cbd6a7ce39c22307100e3fb4a2c0b0a1d/yarl-1.22.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:5a3bf7f62a289fa90f1990422dc8dff5a458469ea71d1624585ec3a4c8d6960f", size = 356047, upload_time = "2025-10-06T14:11:05.115Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/4b/b8/4c0e9e9f597074b208d18cef227d83aac36184bfbc6eab204ea55783dbc5/yarl-1.22.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:de6b9a04c606978fdfe72666fa216ffcf2d1a9f6a381058d4378f8d7b1e5de62", size = 342947, upload_time = "2025-10-06T14:11:08.137Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e0/e5/11f140a58bf4c6ad7aca69a892bff0ee638c31bea4206748fc0df4ebcb3a/yarl-1.22.0-cp313-cp313t-win32.whl", hash = "sha256:1834bb90991cc2999f10f97f5f01317f99b143284766d197e43cd5b45eb18d03", size = 86943, upload_time = "2025-10-06T14:11:10.284Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/31/74/8b74bae38ed7fe6793d0c15a0c8207bbb819cf287788459e5ed230996cdd/yarl-1.22.0-cp313-cp313t-win_amd64.whl", hash = "sha256:ff86011bd159a9d2dfc89c34cfd8aff12875980e3bd6a39ff097887520e60249", size = 93715, upload_time = "2025-10-06T14:11:11.739Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/69/66/991858aa4b5892d57aef7ee1ba6b4d01ec3b7eb3060795d34090a3ca3278/yarl-1.22.0-cp313-cp313t-win_arm64.whl", hash = "sha256:7861058d0582b847bc4e3a4a4c46828a410bca738673f35a29ba3ca5db0b473b", size = 83857, upload_time = "2025-10-06T14:11:13.586Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/46/b3/e20ef504049f1a1c54a814b4b9bed96d1ac0e0610c3b4da178f87209db05/yarl-1.22.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:34b36c2c57124530884d89d50ed2c1478697ad7473efd59cfd479945c95650e4", size = 140520, upload_time = "2025-10-06T14:11:15.465Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e4/04/3532d990fdbab02e5ede063676b5c4260e7f3abea2151099c2aa745acc4c/yarl-1.22.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:0dd9a702591ca2e543631c2a017e4a547e38a5c0f29eece37d9097e04a7ac683", size = 93504, upload_time = "2025-10-06T14:11:17.106Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/11/63/ff458113c5c2dac9a9719ac68ee7c947cb621432bcf28c9972b1c0e83938/yarl-1.22.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:594fcab1032e2d2cc3321bb2e51271e7cd2b516c7d9aee780ece81b07ff8244b", size = 94282, upload_time = "2025-10-06T14:11:19.064Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a7/bc/315a56aca762d44a6aaaf7ad253f04d996cb6b27bad34410f82d76ea8038/yarl-1.22.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f3d7a87a78d46a2e3d5b72587ac14b4c16952dd0887dbb051451eceac774411e", size = 372080, upload_time = "2025-10-06T14:11:20.996Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3f/3f/08e9b826ec2e099ea6e7c69a61272f4f6da62cb5b1b63590bb80ca2e4a40/yarl-1.22.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:852863707010316c973162e703bddabec35e8757e67fcb8ad58829de1ebc8590", size = 338696, upload_time = "2025-10-06T14:11:22.847Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e3/9f/90360108e3b32bd76789088e99538febfea24a102380ae73827f62073543/yarl-1.22.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:131a085a53bfe839a477c0845acf21efc77457ba2bcf5899618136d64f3303a2", size = 387121, upload_time = "2025-10-06T14:11:24.889Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/98/92/ab8d4657bd5b46a38094cfaea498f18bb70ce6b63508fd7e909bd1f93066/yarl-1.22.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:078a8aefd263f4d4f923a9677b942b445a2be970ca24548a8102689a3a8ab8da", size = 394080, upload_time = "2025-10-06T14:11:27.307Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f5/e7/d8c5a7752fef68205296201f8ec2bf718f5c805a7a7e9880576c67600658/yarl-1.22.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bca03b91c323036913993ff5c738d0842fc9c60c4648e5c8d98331526df89784", size = 372661, upload_time = "2025-10-06T14:11:29.387Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b6/2e/f4d26183c8db0bb82d491b072f3127fb8c381a6206a3a56332714b79b751/yarl-1.22.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:68986a61557d37bb90d3051a45b91fa3d5c516d177dfc6dd6f2f436a07ff2b6b", size = 364645, upload_time = "2025-10-06T14:11:31.423Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/80/7c/428e5812e6b87cd00ee8e898328a62c95825bf37c7fa87f0b6bb2ad31304/yarl-1.22.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:4792b262d585ff0dff6bcb787f8492e40698443ec982a3568c2096433660c694", size = 355361, upload_time = "2025-10-06T14:11:33.055Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ec/2a/249405fd26776f8b13c067378ef4d7dd49c9098d1b6457cdd152a99e96a9/yarl-1.22.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:ebd4549b108d732dba1d4ace67614b9545b21ece30937a63a65dd34efa19732d", size = 381451, upload_time = "2025-10-06T14:11:35.136Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/67/a8/fb6b1adbe98cf1e2dd9fad71003d3a63a1bc22459c6e15f5714eb9323b93/yarl-1.22.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:f87ac53513d22240c7d59203f25cc3beac1e574c6cd681bbfd321987b69f95fd", size = 383814, upload_time = "2025-10-06T14:11:37.094Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d9/f9/3aa2c0e480fb73e872ae2814c43bc1e734740bb0d54e8cb2a95925f98131/yarl-1.22.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:22b029f2881599e2f1b06f8f1db2ee63bd309e2293ba2d566e008ba12778b8da", size = 370799, upload_time = "2025-10-06T14:11:38.83Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/50/3c/af9dba3b8b5eeb302f36f16f92791f3ea62e3f47763406abf6d5a4a3333b/yarl-1.22.0-cp314-cp314-win32.whl", hash = "sha256:6a635ea45ba4ea8238463b4f7d0e721bad669f80878b7bfd1f89266e2ae63da2", size = 82990, upload_time = "2025-10-06T14:11:40.624Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ac/30/ac3a0c5bdc1d6efd1b41fa24d4897a4329b3b1e98de9449679dd327af4f0/yarl-1.22.0-cp314-cp314-win_amd64.whl", hash = "sha256:0d6e6885777af0f110b0e5d7e5dda8b704efed3894da26220b7f3d887b839a79", size = 88292, upload_time = "2025-10-06T14:11:42.578Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/df/0a/227ab4ff5b998a1b7410abc7b46c9b7a26b0ca9e86c34ba4b8d8bc7c63d5/yarl-1.22.0-cp314-cp314-win_arm64.whl", hash = "sha256:8218f4e98d3c10d683584cb40f0424f4b9fd6e95610232dd75e13743b070ee33", size = 82888, upload_time = "2025-10-06T14:11:44.863Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/06/5e/a15eb13db90abd87dfbefb9760c0f3f257ac42a5cac7e75dbc23bed97a9f/yarl-1.22.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:45c2842ff0e0d1b35a6bf1cd6c690939dacb617a70827f715232b2e0494d55d1", size = 146223, upload_time = "2025-10-06T14:11:46.796Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/18/82/9665c61910d4d84f41a5bf6837597c89e665fa88aa4941080704645932a9/yarl-1.22.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:d947071e6ebcf2e2bee8fce76e10faca8f7a14808ca36a910263acaacef08eca", size = 95981, upload_time = "2025-10-06T14:11:48.845Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5d/9a/2f65743589809af4d0a6d3aa749343c4b5f4c380cc24a8e94a3c6625a808/yarl-1.22.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:334b8721303e61b00019474cc103bdac3d7b1f65e91f0bfedeec2d56dfe74b53", size = 97303, upload_time = "2025-10-06T14:11:50.897Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b0/ab/5b13d3e157505c43c3b43b5a776cbf7b24a02bc4cccc40314771197e3508/yarl-1.22.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1e7ce67c34138a058fd092f67d07a72b8e31ff0c9236e751957465a24b28910c", size = 361820, upload_time = "2025-10-06T14:11:52.549Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fb/76/242a5ef4677615cf95330cfc1b4610e78184400699bdda0acb897ef5e49a/yarl-1.22.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d77e1b2c6d04711478cb1c4ab90db07f1609ccf06a287d5607fcd90dc9863acf", size = 323203, upload_time = "2025-10-06T14:11:54.225Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8c/96/475509110d3f0153b43d06164cf4195c64d16999e0c7e2d8a099adcd6907/yarl-1.22.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c4647674b6150d2cae088fc07de2738a84b8bcedebef29802cf0b0a82ab6face", size = 363173, upload_time = "2025-10-06T14:11:56.069Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c9/66/59db471aecfbd559a1fd48aedd954435558cd98c7d0da8b03cc6c140a32c/yarl-1.22.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:efb07073be061c8f79d03d04139a80ba33cbd390ca8f0297aae9cce6411e4c6b", size = 373562, upload_time = "2025-10-06T14:11:58.783Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/03/1f/c5d94abc91557384719da10ff166b916107c1b45e4d0423a88457071dd88/yarl-1.22.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e51ac5435758ba97ad69617e13233da53908beccc6cfcd6c34bbed8dcbede486", size = 339828, upload_time = "2025-10-06T14:12:00.686Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5f/97/aa6a143d3afba17b6465733681c70cf175af89f76ec8d9286e08437a7454/yarl-1.22.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:33e32a0dd0c8205efa8e83d04fc9f19313772b78522d1bdc7d9aed706bfd6138", size = 347551, upload_time = "2025-10-06T14:12:02.628Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/43/3c/45a2b6d80195959239a7b2a8810506d4eea5487dce61c2a3393e7fc3c52e/yarl-1.22.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:bf4a21e58b9cde0e401e683ebd00f6ed30a06d14e93f7c8fd059f8b6e8f87b6a", size = 334512, upload_time = "2025-10-06T14:12:04.871Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/86/a0/c2ab48d74599c7c84cb104ebd799c5813de252bea0f360ffc29d270c2caa/yarl-1.22.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:e4b582bab49ac33c8deb97e058cd67c2c50dac0dd134874106d9c774fd272529", size = 352400, upload_time = "2025-10-06T14:12:06.624Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/32/75/f8919b2eafc929567d3d8411f72bdb1a2109c01caaab4ebfa5f8ffadc15b/yarl-1.22.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:0b5bcc1a9c4839e7e30b7b30dd47fe5e7e44fb7054ec29b5bb8d526aa1041093", size = 357140, upload_time = "2025-10-06T14:12:08.362Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/cf/72/6a85bba382f22cf78add705d8c3731748397d986e197e53ecc7835e76de7/yarl-1.22.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:c0232bce2170103ec23c454e54a57008a9a72b5d1c3105dc2496750da8cfa47c", size = 341473, upload_time = "2025-10-06T14:12:10.994Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/35/18/55e6011f7c044dc80b98893060773cefcfdbf60dfefb8cb2f58b9bacbd83/yarl-1.22.0-cp314-cp314t-win32.whl", hash = "sha256:8009b3173bcd637be650922ac455946197d858b3630b6d8787aa9e5c4564533e", size = 89056, upload_time = "2025-10-06T14:12:13.317Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f9/86/0f0dccb6e59a9e7f122c5afd43568b1d31b8ab7dda5f1b01fb5c7025c9a9/yarl-1.22.0-cp314-cp314t-win_amd64.whl", hash = "sha256:9fb17ea16e972c63d25d4a97f016d235c78dd2344820eb35bc034bc32012ee27", size = 96292, upload_time = "2025-10-06T14:12:15.398Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/48/b7/503c98092fb3b344a179579f55814b613c1fbb1c23b3ec14a7b008a66a6e/yarl-1.22.0-cp314-cp314t-win_arm64.whl", hash = "sha256:9f6d73c1436b934e3f01df1e1b21ff765cd1d28c77dfb9ace207f746d4610ee1", size = 85171, upload_time = "2025-10-06T14:12:16.935Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/73/ae/b48f95715333080afb75a4504487cbe142cae1268afc482d06692d605ae6/yarl-1.22.0-py3-none-any.whl", hash = "sha256:1380560bdba02b6b6c90de54133c81c9f2a453dee9912fe58c1dcced1edb7cff", size = 46814, upload_time = "2025-10-06T14:12:53.872Z" }, +] + +[[package]] +name = "zstandard" +version = "0.25.0" +source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" } +sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fd/aa/3e0508d5a5dd96529cdc5a97011299056e14c6505b678fd58938792794b1/zstandard-0.25.0.tar.gz", hash = "sha256:7713e1179d162cf5c7906da876ec2ccb9c3a9dcbdffef0cc7f70c3667a205f0b", size = 711513, upload_time = "2025-09-14T22:15:54.002Z" } +wheels = [ + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/56/7a/28efd1d371f1acd037ac64ed1c5e2b41514a6cc937dd6ab6a13ab9f0702f/zstandard-0.25.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e59fdc271772f6686e01e1b3b74537259800f57e24280be3f29c8a0deb1904dd", size = 795256, upload_time = "2025-09-14T22:15:56.415Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/96/34/ef34ef77f1ee38fc8e4f9775217a613b452916e633c4f1d98f31db52c4a5/zstandard-0.25.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:4d441506e9b372386a5271c64125f72d5df6d2a8e8a2a45a0ae09b03cb781ef7", size = 640565, upload_time = "2025-09-14T22:15:58.177Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/9d/1b/4fdb2c12eb58f31f28c4d28e8dc36611dd7205df8452e63f52fb6261d13e/zstandard-0.25.0-cp310-cp310-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:ab85470ab54c2cb96e176f40342d9ed41e58ca5733be6a893b730e7af9c40550", size = 5345306, upload_time = "2025-09-14T22:16:00.165Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/73/28/a44bdece01bca027b079f0e00be3b6bd89a4df180071da59a3dd7381665b/zstandard-0.25.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:e05ab82ea7753354bb054b92e2f288afb750e6b439ff6ca78af52939ebbc476d", size = 5055561, upload_time = "2025-09-14T22:16:02.22Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e9/74/68341185a4f32b274e0fc3410d5ad0750497e1acc20bd0f5b5f64ce17785/zstandard-0.25.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:78228d8a6a1c177a96b94f7e2e8d012c55f9c760761980da16ae7546a15a8e9b", size = 5402214, upload_time = "2025-09-14T22:16:04.109Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8b/67/f92e64e748fd6aaffe01e2b75a083c0c4fd27abe1c8747fee4555fcee7dd/zstandard-0.25.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:2b6bd67528ee8b5c5f10255735abc21aa106931f0dbaf297c7be0c886353c3d0", size = 5449703, upload_time = "2025-09-14T22:16:06.312Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fd/e5/6d36f92a197c3c17729a2125e29c169f460538a7d939a27eaaa6dcfcba8e/zstandard-0.25.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4b6d83057e713ff235a12e73916b6d356e3084fd3d14ced499d84240f3eecee0", size = 5556583, upload_time = "2025-09-14T22:16:08.457Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d7/83/41939e60d8d7ebfe2b747be022d0806953799140a702b90ffe214d557638/zstandard-0.25.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:9174f4ed06f790a6869b41cba05b43eeb9a35f8993c4422ab853b705e8112bbd", size = 5045332, upload_time = "2025-09-14T22:16:10.444Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b3/87/d3ee185e3d1aa0133399893697ae91f221fda79deb61adbe998a7235c43f/zstandard-0.25.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:25f8f3cd45087d089aef5ba3848cd9efe3ad41163d3400862fb42f81a3a46701", size = 5572283, upload_time = "2025-09-14T22:16:12.128Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0a/1d/58635ae6104df96671076ac7d4ae7816838ce7debd94aecf83e30b7121b0/zstandard-0.25.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:3756b3e9da9b83da1796f8809dd57cb024f838b9eeafde28f3cb472012797ac1", size = 4959754, upload_time = "2025-09-14T22:16:14.225Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/75/d6/57e9cb0a9983e9a229dd8fd2e6e96593ef2aa82a3907188436f22b111ccd/zstandard-0.25.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:81dad8d145d8fd981b2962b686b2241d3a1ea07733e76a2f15435dfb7fb60150", size = 5266477, upload_time = "2025-09-14T22:16:16.343Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d1/a9/ee891e5edf33a6ebce0a028726f0bbd8567effe20fe3d5808c42323e8542/zstandard-0.25.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:a5a419712cf88862a45a23def0ae063686db3d324cec7edbe40509d1a79a0aab", size = 5440914, upload_time = "2025-09-14T22:16:18.453Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/58/08/a8522c28c08031a9521f27abc6f78dbdee7312a7463dd2cfc658b813323b/zstandard-0.25.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:e7360eae90809efd19b886e59a09dad07da4ca9ba096752e61a2e03c8aca188e", size = 5819847, upload_time = "2025-09-14T22:16:20.559Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6f/11/4c91411805c3f7b6f31c60e78ce347ca48f6f16d552fc659af6ec3b73202/zstandard-0.25.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:75ffc32a569fb049499e63ce68c743155477610532da1eb38e7f24bf7cd29e74", size = 5363131, upload_time = "2025-09-14T22:16:22.206Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ef/d6/8c4bd38a3b24c4c7676a7a3d8de85d6ee7a983602a734b9f9cdefb04a5d6/zstandard-0.25.0-cp310-cp310-win32.whl", hash = "sha256:106281ae350e494f4ac8a80470e66d1fe27e497052c8d9c3b95dc4cf1ade81aa", size = 436469, upload_time = "2025-09-14T22:16:25.002Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/93/90/96d50ad417a8ace5f841b3228e93d1bb13e6ad356737f42e2dde30d8bd68/zstandard-0.25.0-cp310-cp310-win_amd64.whl", hash = "sha256:ea9d54cc3d8064260114a0bbf3479fc4a98b21dffc89b3459edd506b69262f6e", size = 506100, upload_time = "2025-09-14T22:16:23.569Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2a/83/c3ca27c363d104980f1c9cee1101cc8ba724ac8c28a033ede6aab89585b1/zstandard-0.25.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:933b65d7680ea337180733cf9e87293cc5500cc0eb3fc8769f4d3c88d724ec5c", size = 795254, upload_time = "2025-09-14T22:16:26.137Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ac/4d/e66465c5411a7cf4866aeadc7d108081d8ceba9bc7abe6b14aa21c671ec3/zstandard-0.25.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a3f79487c687b1fc69f19e487cd949bf3aae653d181dfb5fde3bf6d18894706f", size = 640559, upload_time = "2025-09-14T22:16:27.973Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/12/56/354fe655905f290d3b147b33fe946b0f27e791e4b50a5f004c802cb3eb7b/zstandard-0.25.0-cp311-cp311-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:0bbc9a0c65ce0eea3c34a691e3c4b6889f5f3909ba4822ab385fab9057099431", size = 5348020, upload_time = "2025-09-14T22:16:29.523Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3b/13/2b7ed68bd85e69a2069bcc72141d378f22cae5a0f3b353a2c8f50ef30c1b/zstandard-0.25.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:01582723b3ccd6939ab7b3a78622c573799d5d8737b534b86d0e06ac18dbde4a", size = 5058126, upload_time = "2025-09-14T22:16:31.811Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c9/dd/fdaf0674f4b10d92cb120ccff58bbb6626bf8368f00ebfd2a41ba4a0dc99/zstandard-0.25.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:5f1ad7bf88535edcf30038f6919abe087f606f62c00a87d7e33e7fc57cb69fcc", size = 5405390, upload_time = "2025-09-14T22:16:33.486Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/0f/67/354d1555575bc2490435f90d67ca4dd65238ff2f119f30f72d5cde09c2ad/zstandard-0.25.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:06acb75eebeedb77b69048031282737717a63e71e4ae3f77cc0c3b9508320df6", size = 5452914, upload_time = "2025-09-14T22:16:35.277Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/bb/1f/e9cfd801a3f9190bf3e759c422bbfd2247db9d7f3d54a56ecde70137791a/zstandard-0.25.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9300d02ea7c6506f00e627e287e0492a5eb0371ec1670ae852fefffa6164b072", size = 5559635, upload_time = "2025-09-14T22:16:37.141Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/21/88/5ba550f797ca953a52d708c8e4f380959e7e3280af029e38fbf47b55916e/zstandard-0.25.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:bfd06b1c5584b657a2892a6014c2f4c20e0db0208c159148fa78c65f7e0b0277", size = 5048277, upload_time = "2025-09-14T22:16:38.807Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/46/c0/ca3e533b4fa03112facbe7fbe7779cb1ebec215688e5df576fe5429172e0/zstandard-0.25.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:f373da2c1757bb7f1acaf09369cdc1d51d84131e50d5fa9863982fd626466313", size = 5574377, upload_time = "2025-09-14T22:16:40.523Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/12/9b/3fb626390113f272abd0799fd677ea33d5fc3ec185e62e6be534493c4b60/zstandard-0.25.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6c0e5a65158a7946e7a7affa6418878ef97ab66636f13353b8502d7ea03c8097", size = 4961493, upload_time = "2025-09-14T22:16:43.3Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/cb/d3/23094a6b6a4b1343b27ae68249daa17ae0651fcfec9ed4de09d14b940285/zstandard-0.25.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:c8e167d5adf59476fa3e37bee730890e389410c354771a62e3c076c86f9f7778", size = 5269018, upload_time = "2025-09-14T22:16:45.292Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8c/a7/bb5a0c1c0f3f4b5e9d5b55198e39de91e04ba7c205cc46fcb0f95f0383c1/zstandard-0.25.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:98750a309eb2f020da61e727de7d7ba3c57c97cf6213f6f6277bb7fb42a8e065", size = 5443672, upload_time = "2025-09-14T22:16:47.076Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/27/22/503347aa08d073993f25109c36c8d9f029c7d5949198050962cb568dfa5e/zstandard-0.25.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:22a086cff1b6ceca18a8dd6096ec631e430e93a8e70a9ca5efa7561a00f826fa", size = 5822753, upload_time = "2025-09-14T22:16:49.316Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e2/be/94267dc6ee64f0f8ba2b2ae7c7a2df934a816baaa7291db9e1aa77394c3c/zstandard-0.25.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:72d35d7aa0bba323965da807a462b0966c91608ef3a48ba761678cb20ce5d8b7", size = 5366047, upload_time = "2025-09-14T22:16:51.328Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/7b/a3/732893eab0a3a7aecff8b99052fecf9f605cf0fb5fb6d0290e36beee47a4/zstandard-0.25.0-cp311-cp311-win32.whl", hash = "sha256:f5aeea11ded7320a84dcdd62a3d95b5186834224a9e55b92ccae35d21a8b63d4", size = 436484, upload_time = "2025-09-14T22:16:55.005Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/43/a3/c6155f5c1cce691cb80dfd38627046e50af3ee9ddc5d0b45b9b063bfb8c9/zstandard-0.25.0-cp311-cp311-win_amd64.whl", hash = "sha256:daab68faadb847063d0c56f361a289c4f268706b598afbf9ad113cbe5c38b6b2", size = 506183, upload_time = "2025-09-14T22:16:52.753Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8c/3e/8945ab86a0820cc0e0cdbf38086a92868a9172020fdab8a03ac19662b0e5/zstandard-0.25.0-cp311-cp311-win_arm64.whl", hash = "sha256:22a06c5df3751bb7dc67406f5374734ccee8ed37fc5981bf1ad7041831fa1137", size = 462533, upload_time = "2025-09-14T22:16:53.878Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/82/fc/f26eb6ef91ae723a03e16eddb198abcfce2bc5a42e224d44cc8b6765e57e/zstandard-0.25.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7b3c3a3ab9daa3eed242d6ecceead93aebbb8f5f84318d82cee643e019c4b73b", size = 795738, upload_time = "2025-09-14T22:16:56.237Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/aa/1c/d920d64b22f8dd028a8b90e2d756e431a5d86194caa78e3819c7bf53b4b3/zstandard-0.25.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:913cbd31a400febff93b564a23e17c3ed2d56c064006f54efec210d586171c00", size = 640436, upload_time = "2025-09-14T22:16:57.774Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/53/6c/288c3f0bd9fcfe9ca41e2c2fbfd17b2097f6af57b62a81161941f09afa76/zstandard-0.25.0-cp312-cp312-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:011d388c76b11a0c165374ce660ce2c8efa8e5d87f34996aa80f9c0816698b64", size = 5343019, upload_time = "2025-09-14T22:16:59.302Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/1e/15/efef5a2f204a64bdb5571e6161d49f7ef0fffdbca953a615efbec045f60f/zstandard-0.25.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:6dffecc361d079bb48d7caef5d673c88c8988d3d33fb74ab95b7ee6da42652ea", size = 5063012, upload_time = "2025-09-14T22:17:01.156Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b7/37/a6ce629ffdb43959e92e87ebdaeebb5ac81c944b6a75c9c47e300f85abdf/zstandard-0.25.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:7149623bba7fdf7e7f24312953bcf73cae103db8cae49f8154dd1eadc8a29ecb", size = 5394148, upload_time = "2025-09-14T22:17:03.091Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e3/79/2bf870b3abeb5c070fe2d670a5a8d1057a8270f125ef7676d29ea900f496/zstandard-0.25.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:6a573a35693e03cf1d67799fd01b50ff578515a8aeadd4595d2a7fa9f3ec002a", size = 5451652, upload_time = "2025-09-14T22:17:04.979Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/53/60/7be26e610767316c028a2cbedb9a3beabdbe33e2182c373f71a1c0b88f36/zstandard-0.25.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5a56ba0db2d244117ed744dfa8f6f5b366e14148e00de44723413b2f3938a902", size = 5546993, upload_time = "2025-09-14T22:17:06.781Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/85/c7/3483ad9ff0662623f3648479b0380d2de5510abf00990468c286c6b04017/zstandard-0.25.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:10ef2a79ab8e2974e2075fb984e5b9806c64134810fac21576f0668e7ea19f8f", size = 5046806, upload_time = "2025-09-14T22:17:08.415Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/08/b3/206883dd25b8d1591a1caa44b54c2aad84badccf2f1de9e2d60a446f9a25/zstandard-0.25.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:aaf21ba8fb76d102b696781bddaa0954b782536446083ae3fdaa6f16b25a1c4b", size = 5576659, upload_time = "2025-09-14T22:17:10.164Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/9d/31/76c0779101453e6c117b0ff22565865c54f48f8bd807df2b00c2c404b8e0/zstandard-0.25.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1869da9571d5e94a85a5e8d57e4e8807b175c9e4a6294e3b66fa4efb074d90f6", size = 4953933, upload_time = "2025-09-14T22:17:11.857Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/18/e1/97680c664a1bf9a247a280a053d98e251424af51f1b196c6d52f117c9720/zstandard-0.25.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:809c5bcb2c67cd0ed81e9229d227d4ca28f82d0f778fc5fea624a9def3963f91", size = 5268008, upload_time = "2025-09-14T22:17:13.627Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/1e/73/316e4010de585ac798e154e88fd81bb16afc5c5cb1a72eeb16dd37e8024a/zstandard-0.25.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:f27662e4f7dbf9f9c12391cb37b4c4c3cb90ffbd3b1fb9284dadbbb8935fa708", size = 5433517, upload_time = "2025-09-14T22:17:16.103Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5b/60/dd0f8cfa8129c5a0ce3ea6b7f70be5b33d2618013a161e1ff26c2b39787c/zstandard-0.25.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:99c0c846e6e61718715a3c9437ccc625de26593fea60189567f0118dc9db7512", size = 5814292, upload_time = "2025-09-14T22:17:17.827Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fc/5f/75aafd4b9d11b5407b641b8e41a57864097663699f23e9ad4dbb91dc6bfe/zstandard-0.25.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:474d2596a2dbc241a556e965fb76002c1ce655445e4e3bf38e5477d413165ffa", size = 5360237, upload_time = "2025-09-14T22:17:19.954Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ff/8d/0309daffea4fcac7981021dbf21cdb2e3427a9e76bafbcdbdf5392ff99a4/zstandard-0.25.0-cp312-cp312-win32.whl", hash = "sha256:23ebc8f17a03133b4426bcc04aabd68f8236eb78c3760f12783385171b0fd8bd", size = 436922, upload_time = "2025-09-14T22:17:24.398Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/79/3b/fa54d9015f945330510cb5d0b0501e8253c127cca7ebe8ba46a965df18c5/zstandard-0.25.0-cp312-cp312-win_amd64.whl", hash = "sha256:ffef5a74088f1e09947aecf91011136665152e0b4b359c42be3373897fb39b01", size = 506276, upload_time = "2025-09-14T22:17:21.429Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ea/6b/8b51697e5319b1f9ac71087b0af9a40d8a6288ff8025c36486e0c12abcc4/zstandard-0.25.0-cp312-cp312-win_arm64.whl", hash = "sha256:181eb40e0b6a29b3cd2849f825e0fa34397f649170673d385f3598ae17cca2e9", size = 462679, upload_time = "2025-09-14T22:17:23.147Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/35/0b/8df9c4ad06af91d39e94fa96cc010a24ac4ef1378d3efab9223cc8593d40/zstandard-0.25.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ec996f12524f88e151c339688c3897194821d7f03081ab35d31d1e12ec975e94", size = 795735, upload_time = "2025-09-14T22:17:26.042Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3f/06/9ae96a3e5dcfd119377ba33d4c42a7d89da1efabd5cb3e366b156c45ff4d/zstandard-0.25.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a1a4ae2dec3993a32247995bdfe367fc3266da832d82f8438c8570f989753de1", size = 640440, upload_time = "2025-09-14T22:17:27.366Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d9/14/933d27204c2bd404229c69f445862454dcc101cd69ef8c6068f15aaec12c/zstandard-0.25.0-cp313-cp313-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:e96594a5537722fdfb79951672a2a63aec5ebfb823e7560586f7484819f2a08f", size = 5343070, upload_time = "2025-09-14T22:17:28.896Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/6d/db/ddb11011826ed7db9d0e485d13df79b58586bfdec56e5c84a928a9a78c1c/zstandard-0.25.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:bfc4e20784722098822e3eee42b8e576b379ed72cca4a7cb856ae733e62192ea", size = 5063001, upload_time = "2025-09-14T22:17:31.044Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/db/00/87466ea3f99599d02a5238498b87bf84a6348290c19571051839ca943777/zstandard-0.25.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:457ed498fc58cdc12fc48f7950e02740d4f7ae9493dd4ab2168a47c93c31298e", size = 5394120, upload_time = "2025-09-14T22:17:32.711Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2b/95/fc5531d9c618a679a20ff6c29e2b3ef1d1f4ad66c5e161ae6ff847d102a9/zstandard-0.25.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:fd7a5004eb1980d3cefe26b2685bcb0b17989901a70a1040d1ac86f1d898c551", size = 5451230, upload_time = "2025-09-14T22:17:34.41Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/63/4b/e3678b4e776db00f9f7b2fe58e547e8928ef32727d7a1ff01dea010f3f13/zstandard-0.25.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8e735494da3db08694d26480f1493ad2cf86e99bdd53e8e9771b2752a5c0246a", size = 5547173, upload_time = "2025-09-14T22:17:36.084Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/4e/d5/ba05ed95c6b8ec30bd468dfeab20589f2cf709b5c940483e31d991f2ca58/zstandard-0.25.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:3a39c94ad7866160a4a46d772e43311a743c316942037671beb264e395bdd611", size = 5046736, upload_time = "2025-09-14T22:17:37.891Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/50/d5/870aa06b3a76c73eced65c044b92286a3c4e00554005ff51962deef28e28/zstandard-0.25.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:172de1f06947577d3a3005416977cce6168f2261284c02080e7ad0185faeced3", size = 5576368, upload_time = "2025-09-14T22:17:40.206Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5d/35/398dc2ffc89d304d59bc12f0fdd931b4ce455bddf7038a0a67733a25f550/zstandard-0.25.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:3c83b0188c852a47cd13ef3bf9209fb0a77fa5374958b8c53aaa699398c6bd7b", size = 4954022, upload_time = "2025-09-14T22:17:41.879Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/9a/5c/36ba1e5507d56d2213202ec2b05e8541734af5f2ce378c5d1ceaf4d88dc4/zstandard-0.25.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:1673b7199bbe763365b81a4f3252b8e80f44c9e323fc42940dc8843bfeaf9851", size = 5267889, upload_time = "2025-09-14T22:17:43.577Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/70/e8/2ec6b6fb7358b2ec0113ae202647ca7c0e9d15b61c005ae5225ad0995df5/zstandard-0.25.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:0be7622c37c183406f3dbf0cba104118eb16a4ea7359eeb5752f0794882fc250", size = 5433952, upload_time = "2025-09-14T22:17:45.271Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/7b/01/b5f4d4dbc59ef193e870495c6f1275f5b2928e01ff5a81fecb22a06e22fb/zstandard-0.25.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:5f5e4c2a23ca271c218ac025bd7d635597048b366d6f31f420aaeb715239fc98", size = 5814054, upload_time = "2025-09-14T22:17:47.08Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b2/e5/fbd822d5c6f427cf158316d012c5a12f233473c2f9c5fe5ab1ae5d21f3d8/zstandard-0.25.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4f187a0bb61b35119d1926aee039524d1f93aaf38a9916b8c4b78ac8514a0aaf", size = 5360113, upload_time = "2025-09-14T22:17:48.893Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8e/e0/69a553d2047f9a2c7347caa225bb3a63b6d7704ad74610cb7823baa08ed7/zstandard-0.25.0-cp313-cp313-win32.whl", hash = "sha256:7030defa83eef3e51ff26f0b7bfb229f0204b66fe18e04359ce3474ac33cbc09", size = 436936, upload_time = "2025-09-14T22:17:52.658Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d9/82/b9c06c870f3bd8767c201f1edbdf9e8dc34be5b0fbc5682c4f80fe948475/zstandard-0.25.0-cp313-cp313-win_amd64.whl", hash = "sha256:1f830a0dac88719af0ae43b8b2d6aef487d437036468ef3c2ea59c51f9d55fd5", size = 506232, upload_time = "2025-09-14T22:17:50.402Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d4/57/60c3c01243bb81d381c9916e2a6d9e149ab8627c0c7d7abb2d73384b3c0c/zstandard-0.25.0-cp313-cp313-win_arm64.whl", hash = "sha256:85304a43f4d513f5464ceb938aa02c1e78c2943b29f44a750b48b25ac999a049", size = 462671, upload_time = "2025-09-14T22:17:51.533Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3d/5c/f8923b595b55fe49e30612987ad8bf053aef555c14f05bb659dd5dbe3e8a/zstandard-0.25.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e29f0cf06974c899b2c188ef7f783607dbef36da4c242eb6c82dcd8b512855e3", size = 795887, upload_time = "2025-09-14T22:17:54.198Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8d/09/d0a2a14fc3439c5f874042dca72a79c70a532090b7ba0003be73fee37ae2/zstandard-0.25.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:05df5136bc5a011f33cd25bc9f506e7426c0c9b3f9954f056831ce68f3b6689f", size = 640658, upload_time = "2025-09-14T22:17:55.423Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5d/7c/8b6b71b1ddd517f68ffb55e10834388d4f793c49c6b83effaaa05785b0b4/zstandard-0.25.0-cp314-cp314-manylinux2010_i686.manylinux_2_12_i686.manylinux_2_28_i686.whl", hash = "sha256:f604efd28f239cc21b3adb53eb061e2a205dc164be408e553b41ba2ffe0ca15c", size = 5379849, upload_time = "2025-09-14T22:17:57.372Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a4/86/a48e56320d0a17189ab7a42645387334fba2200e904ee47fc5a26c1fd8ca/zstandard-0.25.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:223415140608d0f0da010499eaa8ccdb9af210a543fac54bce15babbcfc78439", size = 5058095, upload_time = "2025-09-14T22:17:59.498Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f8/ad/eb659984ee2c0a779f9d06dbfe45e2dc39d99ff40a319895df2d3d9a48e5/zstandard-0.25.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2e54296a283f3ab5a26fc9b8b5d4978ea0532f37b231644f367aa588930aa043", size = 5551751, upload_time = "2025-09-14T22:18:01.618Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/61/b3/b637faea43677eb7bd42ab204dfb7053bd5c4582bfe6b1baefa80ac0c47b/zstandard-0.25.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ca54090275939dc8ec5dea2d2afb400e0f83444b2fc24e07df7fdef677110859", size = 6364818, upload_time = "2025-09-14T22:18:03.769Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/31/dc/cc50210e11e465c975462439a492516a73300ab8caa8f5e0902544fd748b/zstandard-0.25.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e09bb6252b6476d8d56100e8147b803befa9a12cea144bbe629dd508800d1ad0", size = 5560402, upload_time = "2025-09-14T22:18:05.954Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c9/ae/56523ae9c142f0c08efd5e868a6da613ae76614eca1305259c3bf6a0ed43/zstandard-0.25.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a9ec8c642d1ec73287ae3e726792dd86c96f5681eb8df274a757bf62b750eae7", size = 4955108, upload_time = "2025-09-14T22:18:07.68Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/98/cf/c899f2d6df0840d5e384cf4c4121458c72802e8bda19691f3b16619f51e9/zstandard-0.25.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:a4089a10e598eae6393756b036e0f419e8c1d60f44a831520f9af41c14216cf2", size = 5269248, upload_time = "2025-09-14T22:18:09.753Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/1b/c0/59e912a531d91e1c192d3085fc0f6fb2852753c301a812d856d857ea03c6/zstandard-0.25.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:f67e8f1a324a900e75b5e28ffb152bcac9fbed1cc7b43f99cd90f395c4375344", size = 5430330, upload_time = "2025-09-14T22:18:11.966Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a0/1d/7e31db1240de2df22a58e2ea9a93fc6e38cc29353e660c0272b6735d6669/zstandard-0.25.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:9654dbc012d8b06fc3d19cc825af3f7bf8ae242226df5f83936cb39f5fdc846c", size = 5811123, upload_time = "2025-09-14T22:18:13.907Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f6/49/fac46df5ad353d50535e118d6983069df68ca5908d4d65b8c466150a4ff1/zstandard-0.25.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:4203ce3b31aec23012d3a4cf4a2ed64d12fea5269c49aed5e4c3611b938e4088", size = 5359591, upload_time = "2025-09-14T22:18:16.465Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c2/38/f249a2050ad1eea0bb364046153942e34abba95dd5520af199aed86fbb49/zstandard-0.25.0-cp314-cp314-win32.whl", hash = "sha256:da469dc041701583e34de852d8634703550348d5822e66a0c827d39b05365b12", size = 444513, upload_time = "2025-09-14T22:18:20.61Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3a/43/241f9615bcf8ba8903b3f0432da069e857fc4fd1783bd26183db53c4804b/zstandard-0.25.0-cp314-cp314-win_amd64.whl", hash = "sha256:c19bcdd826e95671065f8692b5a4aa95c52dc7a02a4c5a0cac46deb879a017a2", size = 516118, upload_time = "2025-09-14T22:18:17.849Z" }, + { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f0/ef/da163ce2450ed4febf6467d77ccb4cd52c4c30ab45624bad26ca0a27260c/zstandard-0.25.0-cp314-cp314-win_arm64.whl", hash = "sha256:d7541afd73985c630bafcd6338d2518ae96060075f9463d7dc14cfb33514383d", size = 476940, upload_time = "2025-09-14T22:18:19.088Z" }, +] diff --git a/webui/dist/assets/charts-B1JvyJzO.js b/webui/dist/assets/charts-B1JvyJzO.js deleted file mode 100644 index 7d2ae929..00000000 Binary files a/webui/dist/assets/charts-B1JvyJzO.js and /dev/null differ diff --git a/webui/dist/assets/charts-simvewUa.js b/webui/dist/assets/charts-simvewUa.js new file mode 100644 index 00000000..389f665b Binary files /dev/null and b/webui/dist/assets/charts-simvewUa.js differ diff --git a/webui/dist/assets/codemirror-TZqPU532.js b/webui/dist/assets/codemirror-TZqPU532.js new file mode 100644 index 00000000..cfe8cb2f Binary files /dev/null and b/webui/dist/assets/codemirror-TZqPU532.js differ diff --git a/webui/dist/assets/dnd-BiPfFtVp.js b/webui/dist/assets/dnd-BiPfFtVp.js new file mode 100644 index 00000000..2cb9ef46 Binary files /dev/null and b/webui/dist/assets/dnd-BiPfFtVp.js differ diff --git a/webui/dist/assets/icons-C3pAHJin.js b/webui/dist/assets/icons-C3pAHJin.js new file mode 100644 index 00000000..1d013c54 Binary files /dev/null and b/webui/dist/assets/icons-C3pAHJin.js differ diff --git a/webui/dist/assets/icons-D6w7t-x9.js b/webui/dist/assets/icons-D6w7t-x9.js deleted file mode 100644 index 2cac469f..00000000 Binary files a/webui/dist/assets/icons-D6w7t-x9.js and /dev/null differ diff --git a/webui/dist/assets/index-BmybQ2BG.css b/webui/dist/assets/index-BmybQ2BG.css deleted file mode 100644 index bb6e4a9a..00000000 Binary files a/webui/dist/assets/index-BmybQ2BG.css and /dev/null differ diff --git a/webui/dist/assets/index-Cga6iLH3.js b/webui/dist/assets/index-Cga6iLH3.js deleted file mode 100644 index 85f669a3..00000000 Binary files a/webui/dist/assets/index-Cga6iLH3.js and /dev/null differ diff --git a/webui/dist/assets/index-Din59EIC.css b/webui/dist/assets/index-Din59EIC.css new file mode 100644 index 00000000..57c924d8 Binary files /dev/null and b/webui/dist/assets/index-Din59EIC.css differ diff --git a/webui/dist/assets/index-ppcjeAmG.js b/webui/dist/assets/index-ppcjeAmG.js new file mode 100644 index 00000000..f5a4dcd5 Binary files /dev/null and b/webui/dist/assets/index-ppcjeAmG.js differ diff --git a/webui/dist/assets/markdown-CKA5gBQ9.js b/webui/dist/assets/markdown-CKA5gBQ9.js new file mode 100644 index 00000000..1d7c44dc Binary files /dev/null and b/webui/dist/assets/markdown-CKA5gBQ9.js differ diff --git a/webui/dist/assets/misc-CDy9pI_Y.js b/webui/dist/assets/misc-CDy9pI_Y.js new file mode 100644 index 00000000..a94a34fe Binary files /dev/null and b/webui/dist/assets/misc-CDy9pI_Y.js differ diff --git a/webui/dist/assets/radix-core-BdJoVJLV.js b/webui/dist/assets/radix-core-BdJoVJLV.js new file mode 100644 index 00000000..6390eb41 Binary files /dev/null and b/webui/dist/assets/radix-core-BdJoVJLV.js differ diff --git a/webui/dist/assets/radix-extra-CTMrA3du.js b/webui/dist/assets/radix-extra-CTMrA3du.js new file mode 100644 index 00000000..083183b4 Binary files /dev/null and b/webui/dist/assets/radix-extra-CTMrA3du.js differ diff --git a/webui/dist/assets/react-vendor-Dtc2IqVY.js b/webui/dist/assets/react-vendor-BmxF9s7Q.js similarity index 98% rename from webui/dist/assets/react-vendor-Dtc2IqVY.js rename to webui/dist/assets/react-vendor-BmxF9s7Q.js index 087b3f14..97721520 100644 Binary files a/webui/dist/assets/react-vendor-Dtc2IqVY.js and b/webui/dist/assets/react-vendor-BmxF9s7Q.js differ diff --git a/webui/dist/assets/reactflow-DtsZHOR4.js b/webui/dist/assets/reactflow-DtsZHOR4.js new file mode 100644 index 00000000..dbf46732 Binary files /dev/null and b/webui/dist/assets/reactflow-DtsZHOR4.js differ diff --git a/webui/dist/assets/router-9vIXuQkh.js b/webui/dist/assets/router-9vIXuQkh.js new file mode 100644 index 00000000..bde8a066 Binary files /dev/null and b/webui/dist/assets/router-9vIXuQkh.js differ diff --git a/webui/dist/assets/router-BWgTyY51.js b/webui/dist/assets/router-BWgTyY51.js deleted file mode 100644 index 78a82272..00000000 Binary files a/webui/dist/assets/router-BWgTyY51.js and /dev/null differ diff --git a/webui/dist/assets/ui-vendor-nTGLnMlb.js b/webui/dist/assets/ui-vendor-nTGLnMlb.js deleted file mode 100644 index 0fcce437..00000000 Binary files a/webui/dist/assets/ui-vendor-nTGLnMlb.js and /dev/null differ diff --git a/webui/dist/assets/uppy-x-2TBvZ1.js b/webui/dist/assets/uppy-x-2TBvZ1.js new file mode 100644 index 00000000..38cfc9fd Binary files /dev/null and b/webui/dist/assets/uppy-x-2TBvZ1.js differ diff --git a/webui/dist/assets/utils-BqoaXoQ1.js b/webui/dist/assets/utils-BqoaXoQ1.js new file mode 100644 index 00000000..6f499b48 Binary files /dev/null and b/webui/dist/assets/utils-BqoaXoQ1.js differ diff --git a/webui/dist/index.html b/webui/dist/index.html index 494a8c93..2743cd31 100644 Binary files a/webui/dist/index.html and b/webui/dist/index.html differ diff --git a/webui/dist/maimai.ico b/webui/dist/maimai.ico index 578b11cd..3c1b131e 100644 Binary files a/webui/dist/maimai.ico and b/webui/dist/maimai.ico differ diff --git a/webui/dist/vite.svg b/webui/dist/vite.svg deleted file mode 100644 index e7b8dfb1..00000000 Binary files a/webui/dist/vite.svg and /dev/null differ
请求类型调用次数输入Token输出TokenToken总量累计花费平均耗时(秒)标准差(秒)
请求类型调用次数输入Token输出TokenToken总量累计花费平均耗时(秒)标准差(秒)每次回复平均调用次数每次回复平均Token数