gardel/Mofox-Core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix：matplotlib炸飞主程序

Browse Source
This commit is contained in:
SengokuCola
2025-04-06 22:15:57 +08:00
parent 61d35063d2
commit ff46d5a7d2
3 changed files with 602 additions and 578 deletions
Download Patch File Download Diff File Expand all files Collapse all files

597
src/gui/logger_gui.py
View File

@@ -1,347 +1,378 @@
import customtkinter as ctk # import customtkinter as ctk
import subprocess # import subprocess
import threading # import threading
import queue # import queue
import re # import re
import os # import os
import signal # import signal
from collections import deque # from collections import deque
# import sys
# 设置应用的外观模式和默认颜色主题 # # 设置应用的外观模式和默认颜色主题
ctk.set_appearance_mode("dark") # ctk.set_appearance_mode("dark")
ctk.set_default_color_theme("blue") # ctk.set_default_color_theme("blue")
class LogViewerApp(ctk.CTk): # class LogViewerApp(ctk.CTk):
"""日志查看器应用的主类，继承自customtkinter的CTk类""" # """日志查看器应用的主类，继承自customtkinter的CTk类"""
def __init__(self): # def __init__(self):
"""初始化日志查看器应用的界面和状态""" # """初始化日志查看器应用的界面和状态"""
super().__init__() # super().__init__()
self.title("日志查看器") # self.title("日志查看器")
self.geometry("1200x800") # self.geometry("1200x800")
# 初始化进程、日志队列、日志数据等变量 # # 标记GUI是否运行中
self.process = None # self.is_running = True
self.log_queue = queue.Queue()
self.log_data = deque(maxlen=10000) # 使用固定长度队列
self.available_levels = set()
self.available_modules = set()
self.sorted_modules = []
self.module_checkboxes = {} # 存储模块复选框的字典
# 日志颜色配置 # # 程序关闭时的清理操作
self.color_config = { # self.protocol("WM_DELETE_WINDOW", self._on_closing)
"time": "#888888",
"DEBUG": "#2196F3",
"INFO": "#4CAF50",
"WARNING": "#FF9800",
"ERROR": "#F44336",
"module": "#D4D0AB",
"default": "#FFFFFF",
}
# 列可见性配置 # # 初始化进程、日志队列、日志数据等变量
self.column_visibility = {"show_time": True, "show_level": True, "show_module": True} # self.process = None
# self.log_queue = queue.Queue()
# self.log_data = deque(maxlen=10000) # 使用固定长度队列
# self.available_levels = set()
# self.available_modules = set()
# self.sorted_modules = []
# self.module_checkboxes = {} # 存储模块复选框的字典
# 选中的日志等级和模块 # # 日志颜色配置
self.selected_levels = set() # self.color_config = {
self.selected_modules = set() # "time": "#888888",
# "DEBUG": "#2196F3",
# "INFO": "#4CAF50",
# "WARNING": "#FF9800",
# "ERROR": "#F44336",
# "module": "#D4D0AB",
# "default": "#FFFFFF",
# }
# 创建界面组件并启动日志队列处理 # # 列可见性配置
self.create_widgets() # self.column_visibility = {"show_time": True, "show_level": True, "show_module": True}
self.after(100, self.process_log_queue)
def create_widgets(self): # # 选中的日志等级和模块
"""创建应用界面的各个组件""" # self.selected_levels = set()
self.grid_columnconfigure(0, weight=1) # self.selected_modules = set()
self.grid_rowconfigure(1, weight=1)
# 控制面板 # # 创建界面组件并启动日志队列处理
control_frame = ctk.CTkFrame(self) # self.create_widgets()
control_frame.grid(row=0, column=0, sticky="ew", padx=10, pady=5) # self.after(100, self.process_log_queue)
self.start_btn = ctk.CTkButton(control_frame, text="启动", command=self.start_process) # def create_widgets(self):
self.start_btn.pack(side="left", padx=5) # """创建应用界面的各个组件"""
# self.grid_columnconfigure(0, weight=1)
# self.grid_rowconfigure(1, weight=1)
self.stop_btn = ctk.CTkButton(control_frame, text="停止", command=self.stop_process, state="disabled") # # 控制面板
self.stop_btn.pack(side="left", padx=5) # control_frame = ctk.CTkFrame(self)
# control_frame.grid(row=0, column=0, sticky="ew", padx=10, pady=5)
self.clear_btn = ctk.CTkButton(control_frame, text="清屏", command=self.clear_logs) # self.start_btn = ctk.CTkButton(control_frame, text="启动", command=self.start_process)
self.clear_btn.pack(side="left", padx=5) # self.start_btn.pack(side="left", padx=5)
column_filter_frame = ctk.CTkFrame(control_frame) # self.stop_btn = ctk.CTkButton(control_frame, text="停止", command=self.stop_process, state="disabled")
column_filter_frame.pack(side="left", padx=20) # self.stop_btn.pack(side="left", padx=5)
self.time_check = ctk.CTkCheckBox(column_filter_frame, text="显示时间", command=self.refresh_logs) # self.clear_btn = ctk.CTkButton(control_frame, text="清屏", command=self.clear_logs)
self.time_check.pack(side="left", padx=5) # self.clear_btn.pack(side="left", padx=5)
self.time_check.select()
self.level_check = ctk.CTkCheckBox(column_filter_frame, text="显示等级", command=self.refresh_logs) # column_filter_frame = ctk.CTkFrame(control_frame)
self.level_check.pack(side="left", padx=5) # column_filter_frame.pack(side="left", padx=20)
self.level_check.select()
self.module_check = ctk.CTkCheckBox(column_filter_frame, text="显示模块", command=self.refresh_logs) # self.time_check = ctk.CTkCheckBox(column_filter_frame, text="显示时间", command=self.refresh_logs)
self.module_check.pack(side="left", padx=5) # self.time_check.pack(side="left", padx=5)
self.module_check.select() # self.time_check.select()
# 筛选面板 # self.level_check = ctk.CTkCheckBox(column_filter_frame, text="显示等级", command=self.refresh_logs)
filter_frame = ctk.CTkFrame(self) # self.level_check.pack(side="left", padx=5)
filter_frame.grid(row=0, column=1, rowspan=2, sticky="ns", padx=5) # self.level_check.select()
ctk.CTkLabel(filter_frame, text="日志等级筛选").pack(pady=5) # self.module_check = ctk.CTkCheckBox(column_filter_frame, text="显示模块", command=self.refresh_logs)
self.level_scroll = ctk.CTkScrollableFrame(filter_frame, width=150, height=200) # self.module_check.pack(side="left", padx=5)
self.level_scroll.pack(fill="both", expand=True, padx=5) # self.module_check.select()
ctk.CTkLabel(filter_frame, text="模块筛选").pack(pady=5) # # 筛选面板
self.module_filter_entry = ctk.CTkEntry(filter_frame, placeholder_text="输入模块过滤词") # filter_frame = ctk.CTkFrame(self)
self.module_filter_entry.pack(pady=5) # filter_frame.grid(row=0, column=1, rowspan=2, sticky="ns", padx=5)
self.module_filter_entry.bind("<KeyRelease>", self.update_module_filter)
self.module_scroll = ctk.CTkScrollableFrame(filter_frame, width=300, height=200) # ctk.CTkLabel(filter_frame, text="日志等级筛选").pack(pady=5)
self.module_scroll.pack(fill="both", expand=True, padx=5) # self.level_scroll = ctk.CTkScrollableFrame(filter_frame, width=150, height=200)
# self.level_scroll.pack(fill="both", expand=True, padx=5)
self.log_text = ctk.CTkTextbox(self, wrap="word") # ctk.CTkLabel(filter_frame, text="模块筛选").pack(pady=5)
self.log_text.grid(row=1, column=0, sticky="nsew", padx=10, pady=5) # self.module_filter_entry = ctk.CTkEntry(filter_frame, placeholder_text="输入模块过滤词")
# self.module_filter_entry.pack(pady=5)
# self.module_filter_entry.bind("<KeyRelease>", self.update_module_filter)
self.init_text_tags() # self.module_scroll = ctk.CTkScrollableFrame(filter_frame, width=300, height=200)
# self.module_scroll.pack(fill="both", expand=True, padx=5)
def update_module_filter(self, event): # self.log_text = ctk.CTkTextbox(self, wrap="word")
"""根据模块过滤词更新模块复选框的显示""" # self.log_text.grid(row=1, column=0, sticky="nsew", padx=10, pady=5)
filter_text = self.module_filter_entry.get().strip().lower()
for module, checkbox in self.module_checkboxes.items():
if filter_text in module.lower():
checkbox.pack(anchor="w", padx=5, pady=2)
else:
checkbox.pack_forget()
def update_filters(self, level, module): # self.init_text_tags()
"""更新日志等级和模块的筛选器"""
if level not in self.available_levels:
self.available_levels.add(level)
self.add_checkbox(self.level_scroll, level, "level")
module_key = self.get_module_key(module) # def update_module_filter(self, event):
if module_key not in self.available_modules: # """根据模块过滤词更新模块复选框的显示"""
self.available_modules.add(module_key) # filter_text = self.module_filter_entry.get().strip().lower()
self.sorted_modules = sorted(self.available_modules, key=lambda x: x.lower()) # for module, checkbox in self.module_checkboxes.items():
self.rebuild_module_checkboxes() # if filter_text in module.lower():
# checkbox.pack(anchor="w", padx=5, pady=2)
# else:
# checkbox.pack_forget()
def rebuild_module_checkboxes(self): # def update_filters(self, level, module):
"""重新构建模块复选框""" # """更新日志等级和模块的筛选器"""
# 清空现有复选框 # if level not in self.available_levels:
for widget in self.module_scroll.winfo_children(): # self.available_levels.add(level)
widget.destroy() # self.add_checkbox(self.level_scroll, level, "level")
self.module_checkboxes.clear()
# 重建排序后的复选框 # module_key = self.get_module_key(module)
for module in self.sorted_modules: # if module_key not in self.available_modules:
self.add_checkbox(self.module_scroll, module, "module") # self.available_modules.add(module_key)
# self.sorted_modules = sorted(self.available_modules, key=lambda x: x.lower())
# self.rebuild_module_checkboxes()
def add_checkbox(self, parent, text, type_): # def rebuild_module_checkboxes(self):
"""在指定父组件中添加复选框""" # """重新构建模块复选框"""
# # 清空现有复选框
# for widget in self.module_scroll.winfo_children():
# widget.destroy()
# self.module_checkboxes.clear()
def update_filter(): # # 重建排序后的复选框
current = cb.get() # for module in self.sorted_modules:
if type_ == "level": # self.add_checkbox(self.module_scroll, module, "module")
(self.selected_levels.add if current else self.selected_levels.discard)(text)
else:
(self.selected_modules.add if current else self.selected_modules.discard)(text)
self.refresh_logs()
cb = ctk.CTkCheckBox(parent, text=text, command=update_filter) # def add_checkbox(self, parent, text, type_):
cb.select() # 初始选中 # """在指定父组件中添加复选框"""
# 手动同步初始状态到集合（关键修复） # def update_filter():
if type_ == "level": # current = cb.get()
self.selected_levels.add(text) # if type_ == "level":
else: # (self.selected_levels.add if current else self.selected_levels.discard)(text)
self.selected_modules.add(text) # else:
# (self.selected_modules.add if current else self.selected_modules.discard)(text)
# self.refresh_logs()
if type_ == "module": # cb = ctk.CTkCheckBox(parent, text=text, command=update_filter)
self.module_checkboxes[text] = cb # cb.select() # 初始选中
cb.pack(anchor="w", padx=5, pady=2)
return cb
def check_filter(self, entry): # # 手动同步初始状态到集合（关键修复）
"""检查日志条目是否符合当前筛选条件""" # if type_ == "level":
level_ok = not self.selected_levels or entry["level"] in self.selected_levels # self.selected_levels.add(text)
module_key = self.get_module_key(entry["module"]) # else:
module_ok = not self.selected_modules or module_key in self.selected_modules # self.selected_modules.add(text)
return level_ok and module_ok
def init_text_tags(self): # if type_ == "module":
"""初始化日志文本的颜色标签""" # self.module_checkboxes[text] = cb
for tag, color in self.color_config.items(): # cb.pack(anchor="w", padx=5, pady=2)
self.log_text.tag_config(tag, foreground=color) # return cb
self.log_text.tag_config("default", foreground=self.color_config["default"])
def start_process(self): # def check_filter(self, entry):
"""启动日志进程并开始读取输出""" # """检查日志条目是否符合当前筛选条件"""
self.process = subprocess.Popen( # level_ok = not self.selected_levels or entry["level"] in self.selected_levels
["nb", "run"], # module_key = self.get_module_key(entry["module"])
stdout=subprocess.PIPE, # module_ok = not self.selected_modules or module_key in self.selected_modules
stderr=subprocess.STDOUT, # return level_ok and module_ok
text=True,
bufsize=1,
encoding="utf-8",
errors="ignore",
)
self.start_btn.configure(state="disabled")
self.stop_btn.configure(state="normal")
threading.Thread(target=self.read_output, daemon=True).start()
def stop_process(self): # def init_text_tags(self):
"""停止日志进程并清理相关资源""" # """初始化日志文本的颜色标签"""
if self.process: # for tag, color in self.color_config.items():
try: # self.log_text.tag_config(tag, foreground=color)
if hasattr(self.process, "pid"): # self.log_text.tag_config("default", foreground=self.color_config["default"])
if os.name == "nt":
subprocess.run(
["taskkill", "/F", "/T", "/PID", str(self.process.pid)], check=True, capture_output=True
)
else:
os.killpg(os.getpgid(self.process.pid), signal.SIGTERM)
except (subprocess.CalledProcessError, ProcessLookupError, OSError) as e:
print(f"终止进程失败: {e}")
finally:
self.process = None
self.log_queue.queue.clear()
self.start_btn.configure(state="normal")
self.stop_btn.configure(state="disabled")
self.refresh_logs()
def read_output(self): # def start_process(self):
"""读取日志进程的输出并放入队列""" # """启动日志进程并开始读取输出"""
try: # self.process = subprocess.Popen(
while self.process and self.process.poll() is None: # ["nb", "run"],
line = self.process.stdout.readline() # stdout=subprocess.PIPE,
if line: # stderr=subprocess.STDOUT,
self.log_queue.put(line) # text=True,
else: # bufsize=1,
break # 避免空循环 # encoding="utf-8",
self.process.stdout.close() # 确保关闭文件描述符 # errors="ignore",
except ValueError: # 处理可能的I/O操作异常 # )
pass # self.start_btn.configure(state="disabled")
# self.stop_btn.configure(state="normal")
# threading.Thread(target=self.read_output, daemon=True).start()
def process_log_queue(self): # def stop_process(self):
"""处理日志队列中的日志条目""" # """停止日志进程并清理相关资源"""
while not self.log_queue.empty(): # if self.process:
line = self.log_queue.get() # try:
self.process_log_line(line) # if hasattr(self.process, "pid"):
self.after(100, self.process_log_queue) # if os.name == "nt":
# subprocess.run(
# ["taskkill", "/F", "/T", "/PID", str(self.process.pid)], check=True, capture_output=True
# )
# else:
# os.killpg(os.getpgid(self.process.pid), signal.SIGTERM)
# except (subprocess.CalledProcessError, ProcessLookupError, OSError) as e:
# print(f"终止进程失败: {e}")
# finally:
# self.process = None
# self.log_queue.queue.clear()
# self.start_btn.configure(state="normal")
# self.stop_btn.configure(state="disabled")
# self.refresh_logs()
def process_log_line(self, line): # def read_output(self):
"""解析单行日志并更新日志数据和筛选器""" # """读取日志进程的输出并放入队列"""
match = re.match( # try:
r"""^ # while self.process and self.process.poll() is None and self.is_running:
(?:(?P<time>\d{2}:\d{2}(?::\d{2})?)\s*\|\s*)? # line = self.process.stdout.readline()
(?P<level>\w+)\s*\|\s* # if line:
(?P<module>.*?) # self.log_queue.put(line)
\s*[-|]\s* # else:
(?P<message>.*) # break # 避免空循环
$""", # self.process.stdout.close() # 确保关闭文件描述符
line.strip(), # except ValueError: # 处理可能的I/O操作异常
re.VERBOSE, # pass
)
if match: # def process_log_queue(self):
groups = match.groupdict() # """处理日志队列中的日志条目"""
time = groups.get("time", "") # while not self.log_queue.empty():
level = groups.get("level", "OTHER") # line = self.log_queue.get()
module = groups.get("module", "UNKNOWN").strip() # self.process_log_line(line)
message = groups.get("message", "").strip()
raw_line = line
else:
time, level, module, message = "", "OTHER", "UNKNOWN", line
raw_line = line
self.update_filters(level, module) # # 仅在GUI仍在运行时继续处理队列
log_entry = {"raw": raw_line, "time": time, "level": level, "module": module, "message": message} # if self.is_running:
self.log_data.append(log_entry) # self.after(100, self.process_log_queue)
if self.check_filter(log_entry): # def process_log_line(self, line):
self.display_log(log_entry) # """解析单行日志并更新日志数据和筛选器"""
# match = re.match(
# r"""^
# (?:(?P<time>\d{2}:\d{2}(?::\d{2})?)\s*\|\s*)?
# (?P<level>\w+)\s*\|\s*
# (?P<module>.*?)
# \s*[-|]\s*
# (?P<message>.*)
# $""",
# line.strip(),
# re.VERBOSE,
# )
def get_module_key(self, module_name): # if match:
"""获取模块名称的标准化键""" # groups = match.groupdict()
cleaned = module_name.strip() # time = groups.get("time", "")
return re.sub(r":\d+$", "", cleaned) # level = groups.get("level", "OTHER")
# module = groups.get("module", "UNKNOWN").strip()
# message = groups.get("message", "").strip()
# raw_line = line
# else:
# time, level, module, message = "", "OTHER", "UNKNOWN", line
# raw_line = line
def display_log(self, entry): # self.update_filters(level, module)
"""在日志文本框中显示日志条目""" # log_entry = {"raw": raw_line, "time": time, "level": level, "module": module, "message": message}
parts = [] # self.log_data.append(log_entry)
tags = []
if self.column_visibility["show_time"] and entry["time"]: # if self.check_filter(log_entry):
parts.append(f"{entry['time']} ") # self.display_log(log_entry)
tags.append("time")
if self.column_visibility["show_level"]: # def get_module_key(self, module_name):
level_tag = entry["level"] if entry["level"] in self.color_config else "default" # """获取模块名称的标准化键"""
parts.append(f"{entry['level']:<8} ") # cleaned = module_name.strip()
tags.append(level_tag) # return re.sub(r":\d+$", "", cleaned)
if self.column_visibility["show_module"]: # def display_log(self, entry):
parts.append(f"{entry['module']} ") # """在日志文本框中显示日志条目"""
tags.append("module") # parts = []
# tags = []
parts.append(f"- {entry['message']}\n") # if self.column_visibility["show_time"] and entry["time"]:
tags.append("default") # parts.append(f"{entry['time']} ")
# tags.append("time")
self.log_text.configure(state="normal") # if self.column_visibility["show_level"]:
for part, tag in zip(parts, tags): # level_tag = entry["level"] if entry["level"] in self.color_config else "default"
self.log_text.insert("end", part, tag) # parts.append(f"{entry['level']:<8} ")
self.log_text.see("end") # tags.append(level_tag)
self.log_text.configure(state="disabled")
def refresh_logs(self): # if self.column_visibility["show_module"]:
"""刷新日志显示，根据筛选条件重新显示日志""" # parts.append(f"{entry['module']} ")
self.column_visibility = { # tags.append("module")
"show_time": self.time_check.get(),
"show_level": self.level_check.get(),
"show_module": self.module_check.get(),
}
self.log_text.configure(state="normal") # parts.append(f"- {entry['message']}\n")
self.log_text.delete("1.0", "end") # tags.append("default")
filtered_logs = [entry for entry in self.log_data if self.check_filter(entry)] # self.log_text.configure(state="normal")
# for part, tag in zip(parts, tags):
# self.log_text.insert("end", part, tag)
# self.log_text.see("end")
# self.log_text.configure(state="disabled")
for entry in filtered_logs: # def refresh_logs(self):
parts = [] # """刷新日志显示，根据筛选条件重新显示日志"""
tags = [] # self.column_visibility = {
# "show_time": self.time_check.get(),
# "show_level": self.level_check.get(),
# "show_module": self.module_check.get(),
# }
if self.column_visibility["show_time"] and entry["time"]: # self.log_text.configure(state="normal")
parts.append(f"{entry['time']} ") # self.log_text.delete("1.0", "end")
tags.append("time")
if self.column_visibility["show_level"]: # filtered_logs = [entry for entry in self.log_data if self.check_filter(entry)]
level_tag = entry["level"] if entry["level"] in self.color_config else "default"
parts.append(f"{entry['level']:<8} ")
tags.append(level_tag)
if self.column_visibility["show_module"]: # for entry in filtered_logs:
parts.append(f"{entry['module']} ") # parts = []
tags.append("module") # tags = []
parts.append(f"- {entry['message']}\n") # if self.column_visibility["show_time"] and entry["time"]:
tags.append("default") # parts.append(f"{entry['time']} ")
# tags.append("time")
for part, tag in zip(parts, tags): # if self.column_visibility["show_level"]:
self.log_text.insert("end", part, tag) # level_tag = entry["level"] if entry["level"] in self.color_config else "default"
# parts.append(f"{entry['level']:<8} ")
# tags.append(level_tag)
self.log_text.see("end") # if self.column_visibility["show_module"]:
self.log_text.configure(state="disabled") # parts.append(f"{entry['module']} ")
# tags.append("module")
def clear_logs(self): # parts.append(f"- {entry['message']}\n")
"""清空日志文本框中的内容""" # tags.append("default")
self.log_text.configure(state="normal")
self.log_text.delete("1.0", "end") # for part, tag in zip(parts, tags):
self.log_text.configure(state="disabled") # self.log_text.insert("end", part, tag)
# self.log_text.see("end")
# self.log_text.configure(state="disabled")
# def clear_logs(self):
# """清空日志文本框中的内容"""
# self.log_text.configure(state="normal")
# self.log_text.delete("1.0", "end")
# self.log_text.configure(state="disabled")
# def _on_closing(self):
# """处理窗口关闭事件，安全清理资源"""
# # 标记GUI已关闭
# self.is_running = False
# # 停止日志进程
# self.stop_process()
# # 安全清理tkinter变量
# for attr_name in list(self.__dict__.keys()):
# if isinstance(getattr(self, attr_name), (ctk.Variable, ctk.StringVar, ctk.IntVar, ctk.DoubleVar, ctk.BooleanVar)):
# try:
# var = getattr(self, attr_name)
# var.set(None)
# except Exception:
# pass
# setattr(self, attr_name, None)
# self.quit()
# sys.exit(0)
if __name__ == "__main__": # if __name__ == "__main__":
# 启动日志查看器应用 # # 启动日志查看器应用
app = LogViewerApp() # app = LogViewerApp()
app.mainloop() # app.mainloop()

544
src/gui/reasoning_gui.py
View File

@@ -1,320 +1,342 @@
import os # import os
import queue # import queue
import sys # import sys
import threading # import threading
import time # import time
from datetime import datetime # from datetime import datetime
from typing import Dict, List # from typing import Dict, List
from typing import Optional # from typing import Optional
sys.path.insert(0, sys.path[0] + "/../") # sys.path.insert(0, sys.path[0] + "/../")
sys.path.insert(0, sys.path[0] + "/../") # sys.path.insert(0, sys.path[0] + "/../")
from src.common.logger import get_module_logger # from src.common.logger import get_module_logger
import customtkinter as ctk # import customtkinter as ctk
from dotenv import load_dotenv # from dotenv import load_dotenv
logger = get_module_logger("gui") # logger = get_module_logger("gui")
# 获取当前文件的目录 # # 获取当前文件的目录
current_dir = os.path.dirname(os.path.abspath(__file__)) # current_dir = os.path.dirname(os.path.abspath(__file__))
# 获取项目根目录 # # 获取项目根目录
root_dir = os.path.abspath(os.path.join(current_dir, "..", "..")) # root_dir = os.path.abspath(os.path.join(current_dir, "..", ".."))
sys.path.insert(0, root_dir) # sys.path.insert(0, root_dir)
from src.common.database import db # noqa: E402 # from src.common.database import db # noqa: E402
# 加载环境变量 # # 加载环境变量
if os.path.exists(os.path.join(root_dir, ".env.dev")): # if os.path.exists(os.path.join(root_dir, ".env.dev")):
load_dotenv(os.path.join(root_dir, ".env.dev")) # load_dotenv(os.path.join(root_dir, ".env.dev"))
logger.info("成功加载开发环境配置") # logger.info("成功加载开发环境配置")
elif os.path.exists(os.path.join(root_dir, ".env")): # elif os.path.exists(os.path.join(root_dir, ".env")):
load_dotenv(os.path.join(root_dir, ".env")) # load_dotenv(os.path.join(root_dir, ".env"))
logger.info("成功加载生产环境配置") # logger.info("成功加载生产环境配置")
else: # else:
logger.error("未找到环境配置文件") # logger.error("未找到环境配置文件")
sys.exit(1) # sys.exit(1)
class ReasoningGUI: # class ReasoningGUI:
def __init__(self): # def __init__(self):
# 记录启动时间戳，转换为Unix时间戳 # # 记录启动时间戳，转换为Unix时间戳
self.start_timestamp = datetime.now().timestamp() # self.start_timestamp = datetime.now().timestamp()
logger.info(f"程序启动时间戳: {self.start_timestamp}") # logger.info(f"程序启动时间戳: {self.start_timestamp}")
# 设置主题 # # 设置主题
ctk.set_appearance_mode("dark") # ctk.set_appearance_mode("dark")
ctk.set_default_color_theme("blue") # ctk.set_default_color_theme("blue")
# 创建主窗口 # # 创建主窗口
self.root = ctk.CTk() # self.root = ctk.CTk()
self.root.title("麦麦推理") # self.root.title("麦麦推理")
self.root.geometry("800x600") # self.root.geometry("800x600")
self.root.protocol("WM_DELETE_WINDOW", self._on_closing) # self.root.protocol("WM_DELETE_WINDOW", self._on_closing)
# 存储群组数据 # # 存储群组数据
self.group_data: Dict[str, List[dict]] = {} # self.group_data: Dict[str, List[dict]] = {}
# 创建更新队列 # # 创建更新队列
self.update_queue = queue.Queue() # self.update_queue = queue.Queue()
# 创建主框架 # # 创建主框架
self.frame = ctk.CTkFrame(self.root) # self.frame = ctk.CTkFrame(self.root)
self.frame.pack(pady=20, padx=20, fill="both", expand=True) # self.frame.pack(pady=20, padx=20, fill="both", expand=True)
# 添加标题 # # 添加标题
self.title = ctk.CTkLabel(self.frame, text="麦麦的脑内所想", font=("Arial", 24)) # self.title = ctk.CTkLabel(self.frame, text="麦麦的脑内所想", font=("Arial", 24))
self.title.pack(pady=10, padx=10) # self.title.pack(pady=10, padx=10)
# 创建左右分栏 # # 创建左右分栏
self.paned = ctk.CTkFrame(self.frame) # self.paned = ctk.CTkFrame(self.frame)
self.paned.pack(fill="both", expand=True, padx=10, pady=10) # self.paned.pack(fill="both", expand=True, padx=10, pady=10)
# 左侧群组列表 # # 左侧群组列表
self.left_frame = ctk.CTkFrame(self.paned, width=200) # self.left_frame = ctk.CTkFrame(self.paned, width=200)
self.left_frame.pack(side="left", fill="y", padx=5, pady=5) # self.left_frame.pack(side="left", fill="y", padx=5, pady=5)
self.group_label = ctk.CTkLabel(self.left_frame, text="群组列表", font=("Arial", 16)) # self.group_label = ctk.CTkLabel(self.left_frame, text="群组列表", font=("Arial", 16))
self.group_label.pack(pady=5) # self.group_label.pack(pady=5)
# 创建可滚动框架来容纳群组按钮 # # 创建可滚动框架来容纳群组按钮
self.group_scroll_frame = ctk.CTkScrollableFrame(self.left_frame, width=180, height=400) # self.group_scroll_frame = ctk.CTkScrollableFrame(self.left_frame, width=180, height=400)
self.group_scroll_frame.pack(pady=5, padx=5, fill="both", expand=True) # self.group_scroll_frame.pack(pady=5, padx=5, fill="both", expand=True)
# 存储群组按钮的字典 # # 存储群组按钮的字典
self.group_buttons: Dict[str, ctk.CTkButton] = {} # self.group_buttons: Dict[str, ctk.CTkButton] = {}
# 当前选中的群组ID # # 当前选中的群组ID
self.selected_group_id: Optional[str] = None # self.selected_group_id: Optional[str] = None
# 右侧内容显示 # # 右侧内容显示
self.right_frame = ctk.CTkFrame(self.paned) # self.right_frame = ctk.CTkFrame(self.paned)
self.right_frame.pack(side="right", fill="both", expand=True, padx=5, pady=5) # self.right_frame.pack(side="right", fill="both", expand=True, padx=5, pady=5)
self.content_label = ctk.CTkLabel(self.right_frame, text="推理内容", font=("Arial", 16)) # self.content_label = ctk.CTkLabel(self.right_frame, text="推理内容", font=("Arial", 16))
self.content_label.pack(pady=5) # self.content_label.pack(pady=5)
# 创建富文本显示框 # # 创建富文本显示框
self.content_text = ctk.CTkTextbox(self.right_frame, width=500, height=400) # self.content_text = ctk.CTkTextbox(self.right_frame, width=500, height=400)
self.content_text.pack(pady=5, padx=5, fill="both", expand=True) # self.content_text.pack(pady=5, padx=5, fill="both", expand=True)
# 配置文本标签 - 只使用颜色 # # 配置文本标签 - 只使用颜色
self.content_text.tag_config("timestamp", foreground="#888888") # 时间戳使用灰色 # self.content_text.tag_config("timestamp", foreground="#888888") # 时间戳使用灰色
self.content_text.tag_config("user", foreground="#4CAF50") # 用户名使用绿色 # self.content_text.tag_config("user", foreground="#4CAF50") # 用户名使用绿色
self.content_text.tag_config("message", foreground="#2196F3") # 消息使用蓝色 # self.content_text.tag_config("message", foreground="#2196F3") # 消息使用蓝色
self.content_text.tag_config("model", foreground="#9C27B0") # 模型名称使用紫色 # self.content_text.tag_config("model", foreground="#9C27B0") # 模型名称使用紫色
self.content_text.tag_config("prompt", foreground="#FF9800") # prompt内容使用橙色 # self.content_text.tag_config("prompt", foreground="#FF9800") # prompt内容使用橙色
self.content_text.tag_config("reasoning", foreground="#FF9800") # 推理过程使用橙色 # self.content_text.tag_config("reasoning", foreground="#FF9800") # 推理过程使用橙色
self.content_text.tag_config("response", foreground="#E91E63") # 回复使用粉色 # self.content_text.tag_config("response", foreground="#E91E63") # 回复使用粉色
self.content_text.tag_config("separator", foreground="#666666") # 分隔符使用深灰色 # self.content_text.tag_config("separator", foreground="#666666") # 分隔符使用深灰色
# 底部控制栏 # # 底部控制栏
self.control_frame = ctk.CTkFrame(self.frame) # self.control_frame = ctk.CTkFrame(self.frame)
self.control_frame.pack(fill="x", padx=10, pady=5) # self.control_frame.pack(fill="x", padx=10, pady=5)
self.clear_button = ctk.CTkButton(self.control_frame, text="清除显示", command=self.clear_display, width=120) # self.clear_button = ctk.CTkButton(self.control_frame, text="清除显示", command=self.clear_display, width=120)
self.clear_button.pack(side="left", padx=5) # self.clear_button.pack(side="left", padx=5)
# 启动自动更新线程 # # 添加标志，标记GUI是否已关闭
self.update_thread = threading.Thread(target=self._auto_update, daemon=True) # self.is_running = True
self.update_thread.start()
# 启动GUI更新检查 # # 启动自动更新线程
self.root.after(100, self._process_queue) # self.update_thread = threading.Thread(target=self._auto_update, daemon=True)
# self.update_thread.start()
def _on_closing(self): # # 启动GUI更新检查
"""处理窗口关闭事件""" # self.root.after(100, self._process_queue)
self.root.quit()
sys.exit(0)
def _process_queue(self): # def _on_closing(self):
"""处理更新队列中的任务""" # """处理窗口关闭事件"""
try: # # 标记GUI已关闭，防止后台线程继续访问tkinter对象
while True: # self.is_running = False
task = self.update_queue.get_nowait()
if task["type"] == "update_group_list":
self._update_group_list_gui()
elif task["type"] == "update_display":
self._update_display_gui(task["group_id"])
except queue.Empty:
pass
finally:
# 继续检查队列
self.root.after(100, self._process_queue)
def _update_group_list_gui(self): # # 安全清理所有可能的tkinter变量
"""在主线程中更新群组列表""" # for attr_name in list(self.__dict__.keys()):
# 清除现有按钮 # if isinstance(getattr(self, attr_name), (ctk.Variable, ctk.StringVar, ctk.IntVar, ctk.DoubleVar, ctk.BooleanVar)):
for button in self.group_buttons.values(): # # 删除变量前安全地将其设置为None
button.destroy() # try:
self.group_buttons.clear() # var = getattr(self, attr_name)
# var.set(None)
# except Exception:
# pass
# setattr(self, attr_name, None)
# 创建新的群组按钮 # # 退出
for group_id in self.group_data.keys(): # self.root.quit()
button = ctk.CTkButton( # sys.exit(0)
self.group_scroll_frame,
text=f"群号: {group_id}",
width=160,
height=30,
corner_radius=8,
command=lambda gid=group_id: self._on_group_select(gid),
)
button.pack(pady=2, padx=5)
self.group_buttons[group_id] = button
# 如果有选中的群组，保持其高亮状态 # def _process_queue(self):
if self.selected_group_id and self.selected_group_id in self.group_buttons: # """处理更新队列中的任务"""
self._highlight_selected_group(self.selected_group_id) # try:
# while True:
# task = self.update_queue.get_nowait()
# if task["type"] == "update_group_list":
# self._update_group_list_gui()
# elif task["type"] == "update_display":
# self._update_display_gui(task["group_id"])
# except queue.Empty:
# pass
# finally:
# # 继续检查队列，但仅在GUI仍在运行时
# if self.is_running:
# self.root.after(100, self._process_queue)
def _on_group_select(self, group_id: str): # def _update_group_list_gui(self):
"""处理群组选择事件""" # """在主线程中更新群组列表"""
self._highlight_selected_group(group_id) # # 清除现有按钮
self._update_display_gui(group_id) # for button in self.group_buttons.values():
# button.destroy()
# self.group_buttons.clear()
def _highlight_selected_group(self, group_id: str): # # 创建新的群组按钮
"""高亮显示选中的群组按钮""" # for group_id in self.group_data.keys():
# 重置所有按钮的颜色 # button = ctk.CTkButton(
for gid, button in self.group_buttons.items(): # self.group_scroll_frame,
if gid == group_id: # text=f"群号: {group_id}",
# 设置选中按钮的颜色 # width=160,
button.configure(fg_color="#1E88E5", hover_color="#1976D2") # height=30,
else: # corner_radius=8,
# 恢复其他按钮的默认颜色 # command=lambda gid=group_id: self._on_group_select(gid),
button.configure(fg_color="#2B2B2B", hover_color="#404040") # )
# button.pack(pady=2, padx=5)
# self.group_buttons[group_id] = button
self.selected_group_id = group_id # # 如果有选中的群组，保持其高亮状态
# if self.selected_group_id and self.selected_group_id in self.group_buttons:
# self._highlight_selected_group(self.selected_group_id)
def _update_display_gui(self, group_id: str): # def _on_group_select(self, group_id: str):
"""在主线程中更新显示内容""" # """处理群组选择事件"""
if group_id in self.group_data: # self._highlight_selected_group(group_id)
self.content_text.delete("1.0", "end") # self._update_display_gui(group_id)
for item in self.group_data[group_id]:
# 时间戳
time_str = item["time"].strftime("%Y-%m-%d %H:%M:%S")
self.content_text.insert("end", f"[{time_str}]\n", "timestamp")
# 用户信息 # def _highlight_selected_group(self, group_id: str):
self.content_text.insert("end", "用户: ", "timestamp") # """高亮显示选中的群组按钮"""
self.content_text.insert("end", f"{item.get('user', '未知')}\n", "user") # # 重置所有按钮的颜色
# for gid, button in self.group_buttons.items():
# if gid == group_id:
# # 设置选中按钮的颜色
# button.configure(fg_color="#1E88E5", hover_color="#1976D2")
# else:
# # 恢复其他按钮的默认颜色
# button.configure(fg_color="#2B2B2B", hover_color="#404040")
# 消息内容 # self.selected_group_id = group_id
self.content_text.insert("end", "消息: ", "timestamp")
self.content_text.insert("end", f"{item.get('message', '')}\n", "message")
# 模型信息 # def _update_display_gui(self, group_id: str):
self.content_text.insert("end", "模型: ", "timestamp") # """在主线程中更新显示内容"""
self.content_text.insert("end", f"{item.get('model', '')}\n", "model") # if group_id in self.group_data:
# self.content_text.delete("1.0", "end")
# for item in self.group_data[group_id]:
# # 时间戳
# time_str = item["time"].strftime("%Y-%m-%d %H:%M:%S")
# self.content_text.insert("end", f"[{time_str}]\n", "timestamp")
# Prompt内容 # # 用户信息
self.content_text.insert("end", "Prompt内容:\n", "timestamp") # self.content_text.insert("end", "用户: ", "timestamp")
prompt_text = item.get("prompt", "") # self.content_text.insert("end", f"{item.get('user', '未知')}\n", "user")
if prompt_text and prompt_text.lower() != "none":
lines = prompt_text.split("\n")
for line in lines:
if line.strip():
self.content_text.insert("end", " " + line + "\n", "prompt")
else:
self.content_text.insert("end", " 无Prompt内容\n", "prompt")
# 推理过程 # # 消息内容
self.content_text.insert("end", "推理过程:\n", "timestamp") # self.content_text.insert("end", "消息: ", "timestamp")
reasoning_text = item.get("reasoning", "") # self.content_text.insert("end", f"{item.get('message', '')}\n", "message")
if reasoning_text and reasoning_text.lower() != "none":
lines = reasoning_text.split("\n")
for line in lines:
if line.strip():
self.content_text.insert("end", " " + line + "\n", "reasoning")
else:
self.content_text.insert("end", " 无推理过程\n", "reasoning")
# 回复内容 # # 模型信息
self.content_text.insert("end", "回复: ", "timestamp") # self.content_text.insert("end", "模型: ", "timestamp")
self.content_text.insert("end", f"{item.get('response', '')}\n", "response") # self.content_text.insert("end", f"{item.get('model', '')}\n", "model")
# 分隔符 # # Prompt内容
self.content_text.insert("end", f"\n{'=' * 50}\n\n", "separator") # self.content_text.insert("end", "Prompt内容:\n", "timestamp")
# prompt_text = item.get("prompt", "")
# if prompt_text and prompt_text.lower() != "none":
# lines = prompt_text.split("\n")
# for line in lines:
# if line.strip():
# self.content_text.insert("end", " " + line + "\n", "prompt")
# else:
# self.content_text.insert("end", " 无Prompt内容\n", "prompt")
# 滚动到顶部 # # 推理过程
self.content_text.see("1.0") # self.content_text.insert("end", "推理过程:\n", "timestamp")
# reasoning_text = item.get("reasoning", "")
# if reasoning_text and reasoning_text.lower() != "none":
# lines = reasoning_text.split("\n")
# for line in lines:
# if line.strip():
# self.content_text.insert("end", " " + line + "\n", "reasoning")
# else:
# self.content_text.insert("end", " 无推理过程\n", "reasoning")
def _auto_update(self): # # 回复内容
"""自动更新函数""" # self.content_text.insert("end", "回复: ", "timestamp")
while True: # self.content_text.insert("end", f"{item.get('response', '')}\n", "response")
try:
# 从数据库获取最新数据，只获取启动时间之后的记录
query = {"time": {"$gt": self.start_timestamp}}
logger.debug(f"查询条件: {query}")
# 先获取一条记录检查时间格式 # # 分隔符
sample = db.reasoning_logs.find_one() # self.content_text.insert("end", f"\n{'=' * 50}\n\n", "separator")
if sample:
logger.debug(f"样本记录时间格式: {type(sample['time'])} 值: {sample['time']}")
cursor = db.reasoning_logs.find(query).sort("time", -1) # # 滚动到顶部
new_data = {} # self.content_text.see("1.0")
total_count = 0
for item in cursor: # def _auto_update(self):
# 调试输出 # """自动更新函数"""
if total_count == 0: # while True:
logger.debug(f"记录时间: {item['time']}, 类型: {type(item['time'])}") # if not self.is_running:
# break # 如果GUI已关闭，停止线程
total_count += 1 # try:
group_id = str(item.get("group_id", "unknown")) # # 从数据库获取最新数据，只获取启动时间之后的记录
if group_id not in new_data: # query = {"time": {"$gt": self.start_timestamp}}
new_data[group_id] = [] # logger.debug(f"查询条件: {query}")
# 转换时间戳为datetime对象 # # 先获取一条记录检查时间格式
if isinstance(item["time"], (int, float)): # sample = db.reasoning_logs.find_one()
time_obj = datetime.fromtimestamp(item["time"]) # if sample:
elif isinstance(item["time"], datetime): # logger.debug(f"样本记录时间格式: {type(sample['time'])} 值: {sample['time']}")
time_obj = item["time"]
else:
logger.warning(f"未知的时间格式: {type(item['time'])}")
time_obj = datetime.now() # 使用当前时间作为后备
new_data[group_id].append( # cursor = db.reasoning_logs.find(query).sort("time", -1)
{ # new_data = {}
"time": time_obj, # total_count = 0
"user": item.get("user", "未知"),
"message": item.get("message", ""),
"model": item.get("model", "未知"),
"reasoning": item.get("reasoning", ""),
"response": item.get("response", ""),
"prompt": item.get("prompt", ""), # 添加prompt字段
}
)
logger.info(f"从数据库加载了 {total_count} 条记录，分布在 {len(new_data)} 个群组中") # for item in cursor:
# # 调试输出
# if total_count == 0:
# logger.debug(f"记录时间: {item['time']}, 类型: {type(item['time'])}")
# 更新数据 # total_count += 1
if new_data != self.group_data: # group_id = str(item.get("group_id", "unknown"))
self.group_data = new_data # if group_id not in new_data:
logger.info("数据已更新，正在刷新显示...") # new_data[group_id] = []
# 将更新任务添加到队列
self.update_queue.put({"type": "update_group_list"})
if self.group_data:
# 如果没有选中的群组，选择最新的群组
if not self.selected_group_id or self.selected_group_id not in self.group_data:
self.selected_group_id = next(iter(self.group_data))
self.update_queue.put({"type": "update_display", "group_id": self.selected_group_id})
except Exception:
logger.exception("自动更新出错")
# 每5秒更新一次 # # 转换时间戳为datetime对象
time.sleep(5) # if isinstance(item["time"], (int, float)):
# time_obj = datetime.fromtimestamp(item["time"])
# elif isinstance(item["time"], datetime):
# time_obj = item["time"]
# else:
# logger.warning(f"未知的时间格式: {type(item['time'])}")
# time_obj = datetime.now() # 使用当前时间作为后备
def clear_display(self): # new_data[group_id].append(
"""清除显示内容""" # {
self.content_text.delete("1.0", "end") # "time": time_obj,
# "user": item.get("user", "未知"),
# "message": item.get("message", ""),
# "model": item.get("model", "未知"),
# "reasoning": item.get("reasoning", ""),
# "response": item.get("response", ""),
# "prompt": item.get("prompt", ""), # 添加prompt字段
# }
# )
def run(self): # logger.info(f"从数据库加载了 {total_count} 条记录，分布在 {len(new_data)} 个群组中")
"""运行GUI"""
self.root.mainloop() # # 更新数据
# if new_data != self.group_data:
# self.group_data = new_data
# logger.info("数据已更新，正在刷新显示...")
# # 将更新任务添加到队列
# self.update_queue.put({"type": "update_group_list"})
# if self.group_data:
# # 如果没有选中的群组，选择最新的群组
# if not self.selected_group_id or self.selected_group_id not in self.group_data:
# self.selected_group_id = next(iter(self.group_data))
# self.update_queue.put({"type": "update_display", "group_id": self.selected_group_id})
# except Exception:
# logger.exception("自动更新出错")
# # 每5秒更新一次
# time.sleep(5)
# def clear_display(self):
# """清除显示内容"""
# self.content_text.delete("1.0", "end")
# def run(self):
# """运行GUI"""
# self.root.mainloop()
def main(): # def main():
app = ReasoningGUI() # app = ReasoningGUI()
app.run() # app.run()
if __name__ == "__main__": # if __name__ == "__main__":
main() # main()

37
src/plugins/person_info/person_info.py
View File

@@ -6,9 +6,9 @@ from typing import Any, Callable, Dict
import datetime import datetime
import asyncio import asyncio
import numpy import numpy
import matplotlib.pyplot as plt # import matplotlib.pyplot as plt
from pathlib import Path # from pathlib import Path
import pandas as pd # import pandas as pd
""" """
@@ -232,7 +232,6 @@ class PersonInfoManager:
logger.info(f"个人信息推断启动: {current_time.strftime('%Y-%m-%d %H:%M:%S')}") logger.info(f"个人信息推断启动: {current_time.strftime('%Y-%m-%d %H:%M:%S')}")
# "msg_interval"推断 # "msg_interval"推断
msg_interval_map = False
msg_interval_lists = await self.get_specific_value_list( msg_interval_lists = await self.get_specific_value_list(
"msg_interval_list", "msg_interval_list",
lambda x: isinstance(x, list) and len(x) >= 100 lambda x: isinstance(x, list) and len(x) >= 100
@@ -246,33 +245,7 @@ class PersonInfoManager:
time_interval.append(delta) time_interval.append(delta)
if len(time_interval) > 30: if len(time_interval) > 30:
time_interval.sort() # 移除matplotlib相关的绘图功能
# 画图(log)
msg_interval_map = True
log_dir = Path("logs/person_info")
log_dir.mkdir(parents=True, exist_ok=True)
plt.figure(figsize=(10, 6))
time_series = pd.Series(time_interval)
# 绘制直方图
plt.hist(time_series, bins=50, density=True, alpha=0.4, color='pink', label='Histogram')
# 绘制KDE曲线（使用相同的实际数据）
time_series.plot(kind='kde', color='mediumpurple', linewidth=1, label='Density')
plt.grid(True, alpha=0.2)
plt.xlim(0, 8000)
plt.title(f"Message Interval Distribution (User: {person_id[:8]}...)")
plt.xlabel("Interval (ms)")
plt.ylabel("Density")
plt.legend(framealpha=0.9, facecolor='white')
img_path = log_dir / f"interval_distribution_{person_id[:8]}.png"
plt.savefig(img_path)
plt.close()
# 画图
filtered_intervals = [t for t in time_interval if t >= 500] filtered_intervals = [t for t in time_interval if t >= 500]
if len(filtered_intervals) > 25: if len(filtered_intervals) > 25:
@@ -285,8 +258,6 @@ class PersonInfoManager:
# 其他... # 其他...
if msg_interval_map:
logger.info("已保存分布图到: logs/person_info")
logger.info(f"个人信息推断结束: {current_time.strftime('%Y-%m-%d %H:%M:%S')}") logger.info(f"个人信息推断结束: {current_time.strftime('%Y-%m-%d %H:%M:%S')}")
await asyncio.sleep(86400) await asyncio.sleep(86400)