import json import os import queue import re import sys import threading import warnings from datetime import datetime from typing import Any, Callable # 确保项目根目录在 Python 路径中(支持直接运行 gui/gui_app.py) _script_dir = os.path.dirname(os.path.abspath(__file__)) _project_root = os.path.dirname(_script_dir) if _project_root not in sys.path: sys.path.insert(0, _project_root) from PIL import Image, ImageTk # 抽离:ADB/配置/参数结构体到 gui_core.py(便于后续模块化) from gui.gui_core import ( RunParams, Runner, find_adb_executable, list_adb_devices, read_config, write_config, ) from path_config import get_logs_dir # 导入日志颜色配置模块 try: from gui.components.log_color_config import ( get_color_config, apply_operation_color, get_operation_type, ) except ImportError: # 如果模块不存在,使用空函数作为回退 def get_color_config(theme: str = "litera"): return {} def apply_operation_color(*args, **kwargs): pass def get_operation_type(line: str) -> str | None: return None # 抑制 PyTorch DataLoader 的 pin_memory 警告(当没有 GPU 时,EasyOCR 会触发此警告) warnings.filterwarnings("ignore", message=".*pin_memory.*", category=UserWarning) warnings.filterwarnings("ignore", message=".*accelerator.*", category=UserWarning) def format_gui_log_line(line: str) -> str: """ 将完整日志行转换为GUI显示用的精简版本。 使用新的日志格式化模块进行美化和格式化处理。 """ try: # 尝试使用新的日志格式化模块 from gui.components.log_viewer import format_gui_log_line as enhanced_formatter return enhanced_formatter(line) except ImportError: # 如果新模块不可用,回退到原来的实现 pass # 回退到原来的精简规则(兼容统一日志格式) s = (line or "").rstrip("\n") if not s: return s ts_part: str | None = None msg_part: str | None = None # 1)新统一日志格式:[YYYY-MM-DD HH:MM:SS.xxx] [LEVEL] ... 业务内容 字段_xxx=... m = re.match(r"^\[(\d{4}-\d{2}-\d{2} [0-9:.]+)\]\s+\[[A-Z]+\]\s+(.*)$", s) if m: ts_part = m.group(1).strip() msg_part = m.group(2).strip() # 2)旧统一日志格式:YYYY-MM-DD HH:MM:SS.xxx - [LEVEL] - ... - 业务内容 elif s[0].isdigit() and " - " in s: parts = s.split(" - ") if len(parts) >= 3: ts_part = parts[0].strip() msg_part = parts[-1].strip() # 如果没解析出时间戳和消息,返回原字符串 if not ts_part or msg_part is None: return s # 从业务文案中拆分出字段_xxx=yyy,非score类字段在GUI中隐藏 keep_tokens: list[str] = [] def _is_score_field(k: str) -> bool: kl = k.lower() return "score" in kl or "match" in kl or "匹配" in k or "相似" in k # 解析字段 words = msg_part.split() clean_words = [] for word in words: if "=" in word: k, v = word.split("=", 1) if _is_score_field(k): keep_tokens.append(word) # else: 其他字段在GUI中隐藏 else: clean_words.append(word) clean_msg = " ".join(clean_words) if keep_tokens: clean_msg = f"{clean_msg} ({', '.join(keep_tokens)})" return f"{ts_part} {clean_msg}" def main(): # 主题优先级:使用 config 中的 gui.theme(若有),否则使用默认明亮主题 'litera' cfg_theme = "darkly" try: cfg_theme = read_config().get("gui", {}).get("theme", "litera") or "litera" except Exception: cfg_theme = "litera" # ttkbootstrap 优先(更美观);没装则回退到原生 tkinter try: import ttkbootstrap as tb from ttkbootstrap.scrolled import ScrolledText import tkinter as tk from tkinter import ttk from ttkbootstrap.constants import LEFT, RIGHT, BOTH, X, Y # 使用 config 中指定的主题名 root = tb.Window(themename=cfg_theme) except Exception: import tkinter as tk from tkinter import ttk from tkinter.constants import LEFT, RIGHT, BOTH, X, Y # type: ignore[assignment] from tkinter.scrolledtext import ScrolledText root = tk.Tk() root.title("抖音福袋挂机 - 可视化控制台") root.geometry("1400x900") # 增大窗口尺寸,提供更多空间 q: queue.Queue[str] = queue.Queue() # ========== 线程安全的日志文件写入器 ========== class ThreadSafeLogWriter: """线程安全的日志文件写入器,确保日志能稳定写入文件""" def __init__(self, log_dir: str | None = None): self._lock = threading.Lock() self._log_dir = log_dir or get_logs_dir() self._log_file_path: str = "" self._log_file_enabled: bool = True self._init_log_file() self._write_error_warned = False def _init_log_file(self) -> None: """初始化日志文件路径(按日期)""" try: # 确保日志目录存在 os.makedirs(self._log_dir, exist_ok=True) # 读取配置,检查是否启用日志文件 cfg = read_config() self._log_file_enabled = bool(cfg.get("log_unified_enabled", True)) # 获取日志文件路径配置 log_path = cfg.get("log_unified_path") or "logs/unified.log" if not os.path.isabs(log_path): from path_config import PROJECT_ROOT log_path = os.path.join(PROJECT_ROOT, log_path) # 如果配置了按日期分割,使用日期后缀 use_dated_logs = cfg.get("logging", {}).get("use_dated_logs", True) if use_dated_logs: # 提取基础文件名(移除扩展名) base_name = os.path.splitext(log_path)[0] today = datetime.now().strftime("%Y-%m-%d") self._log_file_path = f"{base_name}_{today}.log" else: self._log_file_path = log_path except Exception as e: # 如果配置读取失败,使用默认路径 today = datetime.now().strftime("%Y-%m-%d") self._log_file_path = os.path.join( self._log_dir, f"unified_{today}.log" ) if not self._write_error_warned: print(f"[GUI日志] 配置读取失败,使用默认路径: {e}", file=sys.stderr) def write(self, line: str) -> None: """线程安全地写入日志行到文件""" if not self._log_file_enabled: return if not line or not line.strip(): return with self._lock: try: # 检查日期是否变化(如果使用日期日志) cfg = read_config() use_dated_logs = cfg.get("logging", {}).get("use_dated_logs", True) if use_dated_logs: today = datetime.now().strftime("%Y-%m-%d") current_base = os.path.splitext(self._log_file_path)[0] if not current_base.endswith(today): # 日期变化,更新文件路径 base_name = ( current_base.rsplit("_", 1)[0] if "_" in os.path.basename(current_base) else current_base ) self._log_file_path = f"{base_name}_{today}.log" # 确保目录存在 log_dir = os.path.dirname(self._log_file_path) if log_dir: os.makedirs(log_dir, exist_ok=True) # 写入文件(追加模式,UTF-8编码,带BOM避免Windows乱码) with open( self._log_file_path, "a", encoding="utf-8-sig", errors="replace" ) as f: # 如果行已经包含时间戳(格式:YYYY-MM-DD HH:MM:SS),直接写入 # 否则添加时间戳 if line.strip() and not (line[0].isdigit() and " - [" in line): timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[ :-3 ] formatted_line = f"{timestamp} - [GUI] - {line}\n" else: formatted_line = f"{line}\n" f.write(formatted_line) f.flush() # 立即刷新缓冲区,确保日志及时写入磁盘 except PermissionError as e: if not self._write_error_warned: print( f"[GUI日志] 权限错误,无法写入日志文件: {self._log_file_path}", file=sys.stderr, ) print(f"[GUI日志] 错误详情: {e}", file=sys.stderr) self._write_error_warned = True except Exception as e: if not self._write_error_warned: print( f"[GUI日志] 写入日志文件失败: {self._log_file_path}", file=sys.stderr, ) print(f"[GUI日志] 错误详情: {e}", file=sys.stderr) self._write_error_warned = True # 创建日志写入器实例 log_writer = ThreadSafeLogWriter() # 日志格式化已移至模块级别函数 format_gui_log_line() def on_line(line: str): """处理日志行:GUI 显示用精简版本,文件写入用完整版本""" # GUI 显示:使用精简后的版本 try: display_line = format_gui_log_line(line) except Exception: display_line = line q.put(display_line) # 文件:写入完整日志行(不做精简处理) try: log_writer.write(line) except Exception: pass # 文件写入失败不应影响GUI显示 runner = Runner(on_line=on_line) # 顶部:设备选择 + Y偏移(其余运行参数放到左侧分组,避免重复) top = ttk.Frame(root) top.pack(fill=X, padx=12, pady=10) adb_exe = find_adb_executable() devices = list_adb_devices(adb_exe) device_var = tk.StringVar(value=(devices[0] if devices else "")) ttk.Label(top, text="设备:").pack(side=LEFT) device_combo = ttk.Combobox(top, textvariable=device_var, values=devices, width=28) device_combo.pack(side=LEFT, padx=(0, 10)) def refresh_devices(): nonlocal adb_exe adb_exe = find_adb_executable() devs = list_adb_devices(adb_exe) device_combo["values"] = devs if devs and not device_var.get(): device_var.set(devs[0]) if not adb_exe: on_line("[设备] 未找到 adb.exe(请确认已安装 platform-tools)") elif not devs: on_line("[设备] adb 可用,但未发现 device 状态设备(可能未授权/未连接)") ttk.Button(top, text="刷新设备", command=refresh_devices).pack( side=LEFT, padx=(0, 20) ) # 配置区(提前读取配置,供后续使用) cfg = read_config() y_var = tk.IntVar(value=int(cfg.get("y_pianyi", 0) or 0)) ttk.Label(top, text="Y偏移:").pack(side=LEFT) ttk.Spinbox(top, from_=-200, to=200, textvariable=y_var, width=6).pack( side=LEFT, padx=(0, 12) ) # 连续无福袋退出阈值变量(提前声明,避免后续使用前未绑定) fudai_exit_after_misses_var = tk.IntVar( value=int(cfg.get("fudai_exit_after_misses", 30) or 30) ) # 连续无福袋退出阈值(在直播间连续未找到福袋达到该次数时按返回键退出) ttk.Label(top, text="连续无福袋退出阈值:").pack(side=LEFT) ttk.Spinbox( top, from_=1, to=99999, textvariable=fudai_exit_after_misses_var, width=6 ).pack(side=LEFT, padx=(0, 12)) # 中部:左侧配置(使用Notebook标签页)+ 右侧日志/预览(支持拖拽调整宽度) mid = ttk.PanedWindow(root, orient="horizontal") mid.pack(fill=BOTH, expand=True, padx=12, pady=(0, 12)) left_wrap = ttk.Frame(mid) right = ttk.Frame(mid) mid.add(left_wrap, weight=0) # 左侧配置区域 mid.add(right, weight=1) # 右侧日志/预览区域 # 左侧使用Notebook标签页组织配置 left_notebook = ttk.Notebook(left_wrap) left_notebook.pack(fill=BOTH, expand=True) needswitch_var = tk.BooleanVar(value=bool(cfg.get("needswitch", True))) infinite_loop_var = tk.BooleanVar( value=bool(cfg.get("infinite_loop_enabled", False)) ) wait_minutes_var = tk.IntVar(value=int(cfg.get("wait_minutes", 5) or 5)) min_value_var = tk.DoubleVar(value=float(cfg.get("min_prize_value_yuan", 0) or 0)) min_participants_var = tk.IntVar(value=int(cfg.get("min_participants", 0) or 0)) max_participants_var = tk.IntVar(value=int(cfg.get("max_participants", 0) or 0)) skip_gt_seconds_var = tk.IntVar( value=int(cfg.get("skip_if_countdown_gt_seconds", 900) or 900) ) reset_after_swipes_enabled_var = tk.BooleanVar( value=bool(cfg.get("reset_after_swipes_enabled", False)) ) reset_after_swipes_var = tk.IntVar( value=int(cfg.get("reset_after_swipes", 10) or 10) ) # 流式后台截图开关(默认启用) streaming_enabled_var = tk.BooleanVar( value=bool(cfg.get("enable_streaming_screenshot", True)) ) # 按需求:删除"自动养号/随机等待/轻微扰动/定时休息"等设置,仅保留"推荐页养号(爱心/收藏/评论)"配置。 auto_join_var = tk.BooleanVar(value=bool(cfg.get("auto_join_fansclub", False))) fansclub_action_var = tk.StringVar( value=str(cfg.get("fansclub_fail_action", "stay") or "stay").lower() ) fansclub_click_delay_var = tk.DoubleVar( value=float(cfg.get("fansclub_click_delay", 0.6) or 0.6) ) fansclub_auto_wait_var = tk.DoubleVar( value=float(cfg.get("fansclub_auto_join_wait_seconds", 5.0) or 5.0) ) fansclub_manual_wait_var = tk.DoubleVar( value=float(cfg.get("fansclub_manual_wait_seconds", 3.0) or 3.0) ) # Web端新增配置变量 - 高价值预约相关 high_value_fudai_enabled_var = tk.BooleanVar( value=bool(cfg.get("high_value_fudai_enabled", False)) ) high_value_fudai_threshold_yuan_var = tk.DoubleVar( value=float(cfg.get("high_value_fudai_threshold_yuan", 1000) or 1000) ) high_value_fudai_join_ahead_seconds_var = tk.IntVar( value=int(cfg.get("high_value_fudai_join_ahead_seconds", 120) or 120) ) high_value_fudai_max_swipe_back_var = tk.IntVar( value=int(cfg.get("high_value_fudai_max_swipe_back", 60) or 60) ) high_value_fudai_max_reservations_var = tk.IntVar( value=int(cfg.get("high_value_fudai_max_reservations", 5) or 5) ) high_value_fudai_after_action_var = tk.StringVar( value=str(cfg.get("high_value_fudai_after_action", "continue") or "continue") ) high_value_room_revisit_enabled_var = tk.BooleanVar( value=bool(cfg.get("high_value_room_revisit_enabled", True)) ) high_value_room_revisit_only_current_run_var = tk.BooleanVar( value=bool(cfg.get("high_value_room_revisit_only_current_run", False)) ) reservation_back_verify_enabled_var = tk.BooleanVar( value=bool(cfg.get("reservation_back_verify_enabled", True)) ) reservation_back_swipe_delay_var = tk.DoubleVar( value=float(cfg.get("reservation_back_swipe_delay", 0) or 0) ) reservation_preempt_min_value_var = tk.DoubleVar( value=float(cfg.get("reservation_preempt_min_value", 0) or 0) ) fudai_find_max_attempts_var = tk.IntVar( value=int(cfg.get("fudai_find_max_attempts", 0) or 0) ) fudai_icon_retry_delay_seconds_var = tk.DoubleVar( value=float(cfg.get("fudai_icon_retry_delay_seconds", 0.6) or 0.6) ) fudai_icon_max_wait_seconds_var = tk.DoubleVar( value=float(cfg.get("fudai_icon_max_wait_seconds", 5.0) or 5.0) ) fudai_disable_content_recognition_var = tk.BooleanVar( value=bool(cfg.get("fudai_disable_content_recognition", False)) ) fudai_disable_task_recognition_var = tk.BooleanVar( value=bool(cfg.get("fudai_disable_task_recognition", False)) ) fudai_exit_after_misses_var = tk.IntVar( value=int(cfg.get("fudai_exit_after_misses", 30) or 30) ) fudai_click_wait_seconds_var = tk.DoubleVar( value=float(cfg.get("fudai_click_wait_seconds", 1.0) or 1.0) ) switch_room_wait_after_stage_diag_seconds_var = tk.DoubleVar( value=float(cfg.get("switch_room_wait_after_stage_diag_seconds", 7.0) or 7.0) ) live_room_match_threshold_var = tk.DoubleVar( value=float(cfg.get("live_room_match_threshold", 0.8) or 0.8) ) # 滑动速度(毫秒) swipe_duration_ms_var = tk.IntVar( value=int(cfg.get("swipe_duration_ms", 600) or 600) ) # 推荐页养号:爱心/收藏/评论(基于图标模板匹配 + 坐标点击) yg_enabled_var = tk.BooleanVar(value=bool(cfg.get("yanghao_enabled", True))) yg_actions_enabled_var = tk.BooleanVar( value=bool(cfg.get("yanghao_enable_actions", True)) ) yg_only_var = tk.BooleanVar(value=bool(cfg.get("yanghao_only", False))) yg_recommend_duration_var = tk.IntVar( value=int(cfg.get("yanghao_recommend_duration_seconds", 60) or 60) ) yg_recommend_interval_var = tk.IntVar( value=int(cfg.get("yanghao_recommend_interval_seconds", 0) or 0) ) yg_like_prob_var = tk.DoubleVar( value=float(cfg.get("yanghao_like_prob", 0.0) or 0.0) ) yg_fav_prob_var = tk.DoubleVar(value=float(cfg.get("yanghao_fav_prob", 0.0) or 0.0)) yg_comment_prob_var = tk.DoubleVar( value=float(cfg.get("yanghao_comment_prob", 0.0) or 0.0) ) yg_icon_roi_size_var = tk.IntVar( value=int(cfg.get("yanghao_icon_roi_size", 240) or 240) ) yg_icon_match_threshold_var = tk.DoubleVar( value=float(cfg.get("yanghao_icon_match_threshold", 0.72) or 0.72) ) yg_step_screenshot_var = tk.BooleanVar( value=bool(cfg.get("yanghao_step_screenshot", False)) ) yg_like_roi_offset_x_var = tk.IntVar( value=int(cfg.get("yanghao_like_roi_offset_x", 0) or 0) ) yg_like_roi_offset_y_var = tk.IntVar( value=int(cfg.get("yanghao_like_roi_offset_y", 0) or 0) ) yg_fav_roi_offset_x_var = tk.IntVar( value=int(cfg.get("yanghao_fav_roi_offset_x", 0) or 0) ) yg_fav_roi_offset_y_var = tk.IntVar( value=int(cfg.get("yanghao_fav_roi_offset_y", 0) or 0) ) yg_like_icon_x_var = tk.IntVar(value=int(cfg.get("yanghao_like_icon_x", 0) or 0)) yg_like_icon_y_var = tk.IntVar(value=int(cfg.get("yanghao_like_icon_y", 0) or 0)) yg_fav_icon_x_var = tk.IntVar(value=int(cfg.get("yanghao_fav_icon_x", 0) or 0)) yg_fav_icon_y_var = tk.IntVar(value=int(cfg.get("yanghao_fav_icon_y", 0) or 0)) yg_like_template_path_var = tk.StringVar( value=str( cfg.get("yanghao_like_template_path", "assets/like.png") or "assets/like.png" ) ) yg_fav_template_path_var = tk.StringVar( value=str( cfg.get("yanghao_fav_template_path", "assets/fav.png") or "assets/fav.png" ) ) yg_after_dwell_direction_var = tk.StringVar( value=str(cfg.get("yanghao_after_dwell_swipe_direction", "up") or "up") ) yg_after_dwell_distance_var = tk.IntVar( value=int(cfg.get("yanghao_after_dwell_swipe_distance_px", 900) or 900) ) yg_comment_btn_x_var = tk.IntVar( value=int(cfg.get("yanghao_comment_btn_x", 0) or 0) ) yg_comment_btn_y_var = tk.IntVar( value=int(cfg.get("yanghao_comment_btn_y", 0) or 0) ) yg_comment_input_x_var = tk.IntVar( value=int(cfg.get("yanghao_comment_input_x", 0) or 0) ) yg_comment_input_y_var = tk.IntVar( value=int(cfg.get("yanghao_comment_input_y", 0) or 0) ) yg_comment_send_x_var = tk.IntVar( value=int(cfg.get("yanghao_comment_send_x", 0) or 0) ) yg_comment_send_y_var = tk.IntVar( value=int(cfg.get("yanghao_comment_send_y", 0) or 0) ) yg_comment_close_x_var = tk.IntVar( value=int(cfg.get("yanghao_comment_close_x", 0) or 0) ) yg_comment_close_y_var = tk.IntVar( value=int(cfg.get("yanghao_comment_close_y", 0) or 0) ) fudai_quiet_hours_enabled_var = tk.BooleanVar( value=bool(cfg.get("fudai_quiet_hours_enabled", True)) ) fudai_quiet_start_hour_var = tk.IntVar( value=int(cfg.get("fudai_quiet_start_hour", 2) or 2) ) fudai_quiet_end_hour_var = tk.IntVar( value=int(cfg.get("fudai_quiet_end_hour", 7) or 7) ) # 阶段诊断时间参数(用于调试) stage_diag_max_time_var = tk.DoubleVar( value=float(cfg.get("stage_diag_max_time", 10.0) or 10.0) ) stage_diag_max_step_time_var = tk.DoubleVar( value=float(cfg.get("stage_diag_max_step_time", 2.0) or 2.0) ) enable_ocr_mode1_var = tk.BooleanVar(value=bool(cfg.get("enable_ocr_mode1", False))) # 福袋模板匹配开关和阈值 fudai_template_match_enabled_var = tk.BooleanVar( value=bool(cfg.get("fudai_template_match_enabled", False)) ) fudai_template_match_threshold_var = tk.DoubleVar( value=float(cfg.get("fudai_template_match_threshold", 0.7) or 0.7) ) # 福袋详情页模板匹配阈值(0.0~1.0,默认0.7) fudai_detail_template_threshold_var = tk.DoubleVar( value=float(cfg.get("fudai_detail_template_threshold", 0.7) or 0.7) ) # 开奖页面红色占比阈值(0.0~1.0,默认0.9) lucky_draw_red_ratio_threshold_var = tk.DoubleVar( value=float(cfg.get("lucky_draw_red_ratio_threshold", 0.9) or 0.9) ) # 优惠券模板匹配阈值(0.0~1.0,默认0.75) coupon_template_match_threshold_var = tk.DoubleVar( value=float(cfg.get("coupon_template_match_threshold", 0.75) or 0.75) ) # 参与按钮红色占比阈值(0.0~1.0,默认0.25) attend_button_red_ratio_threshold_var = tk.DoubleVar( value=float(cfg.get("attend_button_red_ratio_threshold", 0.25) or 0.25) ) # 粉丝团加入红色占比阈值(0.0~1.0,默认0.25) fansclub_join_red_ratio_threshold_var = tk.DoubleVar( value=float(cfg.get("fansclub_join_red_ratio_threshold", 0.25) or 0.25) ) # 调试图像开关 & 清理相关变量 debug_captures_enabled_var = tk.BooleanVar( value=bool( cfg.get("debug_captures", {}).get("enabled", False) if isinstance(cfg.get("debug_captures"), dict) else False ) ) # 调试图像清理相关变量 debug_captures_auto_cleanup_var = tk.BooleanVar( value=bool( cfg.get("debug_captures", {}).get("auto_cleanup", True) if isinstance(cfg.get("debug_captures"), dict) else True ) ) debug_captures_keep_days_var = tk.IntVar( value=int( cfg.get("debug_captures", {}).get("keep_days", 7) if isinstance(cfg.get("debug_captures"), dict) else 7 ) ) debug_captures_max_files_var = tk.IntVar( value=int( cfg.get("debug_captures", {}).get("max_files", 2000) if isinstance(cfg.get("debug_captures"), dict) else 2000 ) ) debug_captures_async_save_var = tk.BooleanVar( value=bool( cfg.get("debug_captures", {}).get("async_save", True) if isinstance(cfg.get("debug_captures"), dict) else True ) ) debug_captures_log_on_complete_var = tk.BooleanVar( value=bool( cfg.get("debug_captures", {}).get("log_on_complete", False) if isinstance(cfg.get("debug_captures"), dict) else False ) ) # 异步保存计数显示变量 debug_async_success_var = tk.IntVar(value=0) debug_async_failure_var = tk.IntVar(value=0) # 日志配置变量 logging_beautify_var = tk.BooleanVar( value=bool(cfg.get("logging", {}).get("beautify_output", True)) ) logging_color_var = tk.BooleanVar( value=bool(cfg.get("logging", {}).get("color_output", True)) ) logging_show_timestamps_var = tk.BooleanVar( value=bool(cfg.get("logging", {}).get("show_timestamps", True)) ) logging_performance_enabled_var = tk.BooleanVar( value=bool( cfg.get("logging", {}).get("performance_tracking", {}).get("enabled", True) ) ) logging_track_functions_var = tk.BooleanVar( value=bool( cfg.get("logging", {}) .get("performance_tracking", {}) .get("track_function_calls", True) ) ) logging_debug_level_var = tk.StringVar( value=str(cfg.get("logging", {}).get("debug_detail_level", "normal")) ) logging_error_level_var = tk.StringVar( value=str(cfg.get("logging", {}).get("error_detail_level", "full")) ) logging_action_format_var = tk.StringVar( value=str(cfg.get("logging", {}).get("action_log_format", "concise")) ) # GUI 主题变量 gui_theme_var = tk.StringVar( value=str(cfg.get("gui", {}).get("theme", "litera") or "litera") ) # 倒计时小于阈值参数 skip_lt_seconds_var = tk.IntVar( value=int(cfg.get("skip_if_countdown_lt_seconds", 10) or 10) ) # 创建左侧配置标签页 # 标签页1:运行设置 run_tab = ttk.Frame(left_notebook) left_notebook.add(run_tab, text="运行设置") run_box = ttk.LabelFrame(run_tab, text="基本运行参数") run_box.pack(fill=X, padx=10, pady=(10, 10)) r0 = ttk.Frame(run_box) r0.pack(fill=X, padx=10, pady=(10, 6)) ttk.Checkbutton(r0, text="允许切换直播间", variable=needswitch_var).pack(side=LEFT) r1 = ttk.Frame(run_box) r1.pack(fill=X, padx=10, pady=(0, 10)) ttk.Checkbutton(r1, text="无限循环模式", variable=infinite_loop_var).pack(side=LEFT) ttk.Label(r1, text="运行时长(分钟):").pack(side=LEFT, padx=(10, 0)) wait_minutes_spinbox = ttk.Spinbox( r1, from_=1, to=60, textvariable=wait_minutes_var, width=6 ) wait_minutes_spinbox.pack(side=LEFT, padx=(0, 12)) # 根据无限循环开关状态,启用/禁用运行时长输入框 def update_wait_minutes_state(*args): if infinite_loop_var.get(): wait_minutes_spinbox.config(state="disabled") else: wait_minutes_spinbox.config(state="normal") infinite_loop_var.trace("w", update_wait_minutes_state) update_wait_minutes_state() # 初始化状态 ttk.Label(r1, text="倒计时大于(秒)时不参与(高价值可预约):").pack(side=LEFT) ttk.Spinbox(r1, from_=0, to=3600, textvariable=skip_gt_seconds_var, width=6).pack( side=LEFT ) r2 = ttk.Frame(run_box) r2.pack(fill=X, padx=10, pady=(0, 10)) ttk.Checkbutton( r2, text="切换N次后回到第一个", variable=reset_after_swipes_enabled_var ).pack(side=LEFT) ttk.Label(r2, text="次数:").pack(side=LEFT, padx=(10, 0)) ttk.Spinbox( r2, from_=1, to=9999, textvariable=reset_after_swipes_var, width=6 ).pack(side=LEFT) ttk.Label(r2, text="(触发后会向上回退)").pack(side=LEFT, padx=(6, 0)) # 标签页2:筛选设置 filter_tab = ttk.Frame(left_notebook) left_notebook.add(filter_tab, text="筛选设置") cfg_box = ttk.LabelFrame(filter_tab, text="福袋筛选条件") cfg_box.pack(fill=X, padx=10, pady=(10, 10)) row = ttk.Frame(cfg_box) row.pack(fill=X, padx=10, pady=(10, 8)) ttk.Label(row, text="最低价值(元):").pack(side=LEFT) ttk.Spinbox( row, from_=0, to=99999, increment=1, textvariable=min_value_var, width=10 ).pack(side=LEFT) rowp = ttk.Frame(cfg_box) rowp.pack(fill=X, padx=10, pady=(0, 8)) ttk.Label(rowp, text="参与人数范围:").pack(side=LEFT) ttk.Spinbox( rowp, from_=0, to=99999999, increment=1, textvariable=min_participants_var, width=10, ).pack(side=LEFT) ttk.Label(rowp, text=" ~ ").pack(side=LEFT) ttk.Spinbox( rowp, from_=0, to=99999999, increment=1, textvariable=max_participants_var, width=10, ).pack(side=LEFT) ttk.Label(rowp, text="(填0表示不限制)").pack(side=LEFT) row2 = ttk.Frame(cfg_box) row2.pack(fill=X, padx=10, pady=(0, 8)) ttk.Label(row2, text="倒计时小于(秒)时不参与:").pack(side=LEFT) ttk.Spinbox( row2, from_=0, to=300, increment=1, textvariable=skip_lt_seconds_var, width=6 ).pack(side=LEFT) ttk.Label(row2, text="(剩余时间太短,不参与)").pack(side=LEFT, padx=(6, 0)) row3 = ttk.Frame(cfg_box) row3.pack(fill=X, padx=10, pady=(0, 8)) ttk.Checkbutton( row3, text="自动加入粉丝团(谨慎:可能消耗钻石)", variable=auto_join_var ).pack(side=LEFT) row4 = ttk.Frame(cfg_box) row4.pack(fill=X, padx=10, pady=(0, 10)) ttk.Label(row4, text="粉丝团失败策略:").pack(side=LEFT) ttk.Combobox( row4, textvariable=fansclub_action_var, values=["stay", "switch"], width=10, state="readonly", ).pack(side=LEFT) ttk.Label(row4, text="(stay=停留,switch=切换直播间)").pack( side=LEFT, padx=(6, 0) ) # 粉丝团等待/点击延迟设置 row4b = ttk.Frame(cfg_box) row4b.pack(fill=X, padx=10, pady=(0, 8)) ttk.Label(row4b, text="粉丝团点击延迟(s):").pack(side=LEFT) ttk.Spinbox( row4b, from_=0.1, to=5.0, increment=0.1, textvariable=fansclub_click_delay_var, width=6, ).pack(side=LEFT, padx=(6, 12)) ttk.Label(row4b, text="自动加入等待(s):").pack(side=LEFT) ttk.Spinbox( row4b, from_=0.5, to=10.0, increment=0.5, textvariable=fansclub_auto_wait_var, width=6, ).pack(side=LEFT, padx=(6, 12)) ttk.Label(row4b, text="手动加入等待(s):").pack(side=LEFT) ttk.Spinbox( row4b, from_=0.5, to=10.0, increment=0.5, textvariable=fansclub_manual_wait_var, width=6, ).pack(side=LEFT, padx=(6, 0)) # 标签页3:高价值预约 reservation_tab_left = ttk.Frame(left_notebook) left_notebook.add(reservation_tab_left, text="高价值预约") reservation_box = ttk.LabelFrame(reservation_tab_left, text="高价值福袋预约参与") reservation_box.pack(fill=X, padx=10, pady=(10, 10)) # 预约启用开关 res_r0 = ttk.Frame(reservation_box) res_r0.pack(fill=X, padx=10, pady=(10, 8)) ttk.Checkbutton( res_r0, text="启用预约(价值≥阈值)", variable=high_value_fudai_enabled_var ).pack(side=LEFT) # 价值阈值和提前参与时间 res_r1 = ttk.Frame(reservation_box) res_r1.pack(fill=X, padx=10, pady=(0, 8)) ttk.Label(res_r1, text="价值阈值(元):").pack(side=LEFT) ttk.Spinbox( res_r1, from_=0, to=99999, increment=100, textvariable=high_value_fudai_threshold_yuan_var, width=10, ).pack(side=LEFT) ttk.Label(res_r1, text="提前参与(秒):").pack(side=LEFT, padx=(20, 0)) ttk.Spinbox( res_r1, from_=5, to=900, increment=10, textvariable=high_value_fudai_join_ahead_seconds_var, width=8, ).pack(side=LEFT) # 最多回退次数 res_r2 = ttk.Frame(reservation_box) res_r2.pack(fill=X, padx=10, pady=(0, 8)) ttk.Label(res_r2, text="最多回退直播间次数:").pack(side=LEFT) ttk.Spinbox( res_r2, from_=0, to=300, increment=5, textvariable=high_value_fudai_max_swipe_back_var, width=8, ).pack(side=LEFT) ttk.Label(res_r2, text="(0=不限制)").pack(side=LEFT, padx=(6, 0)) # 最多记录数量和完成后策略 res_r3 = ttk.Frame(reservation_box) res_r3.pack(fill=X, padx=10, pady=(0, 8)) ttk.Label(res_r3, text="最多记录数量:").pack(side=LEFT) ttk.Spinbox( res_r3, from_=1, to=50, increment=1, textvariable=high_value_fudai_max_reservations_var, width=6, ).pack(side=LEFT) ttk.Label(res_r3, text="完成后策略:").pack(side=LEFT, padx=(20, 0)) ttk.Combobox( res_r3, textvariable=high_value_fudai_after_action_var, values=["continue", "stay"], width=10, state="readonly", ).pack(side=LEFT) ttk.Label(res_r3, text="(stay=停留,continue=继续)").pack(side=LEFT, padx=(6, 0)) # 高价值房间回访 res_r4 = ttk.Frame(reservation_box) res_r4.pack(fill=X, padx=10, pady=(0, 8)) ttk.Checkbutton( res_r4, text="启用高价值房间回访", variable=high_value_room_revisit_enabled_var ).pack(side=LEFT) ttk.Checkbutton( res_r4, text="仅当前运行", variable=high_value_room_revisit_only_current_run_var ).pack(side=LEFT, padx=(20, 0)) # 预约回退校验 res_r5 = ttk.Frame(reservation_box) res_r5.pack(fill=X, padx=10, pady=(0, 8)) ttk.Checkbutton( res_r5, text="预约回退校验", variable=reservation_back_verify_enabled_var ).pack(side=LEFT) # 回退滑延迟和预约抢占最小价值 res_r6 = ttk.Frame(reservation_box) res_r6.pack(fill=X, padx=10, pady=(0, 10)) ttk.Label(res_r6, text="回退滑延迟(秒):").pack(side=LEFT) ttk.Spinbox( res_r6, from_=0.0, to=10.0, increment=0.1, textvariable=reservation_back_swipe_delay_var, width=8, ).pack(side=LEFT) ttk.Label(res_r6, text="预约抢占最小价值(元):").pack(side=LEFT, padx=(20, 0)) ttk.Spinbox( res_r6, from_=0, to=99999, increment=100, textvariable=reservation_preempt_min_value_var, width=10, ).pack(side=LEFT) # 标签页4:养号设置 yanghao_tab = ttk.Frame(left_notebook) left_notebook.add(yanghao_tab, text="养号设置") yg_box = ttk.LabelFrame(yanghao_tab, text="推荐页养号(爱心/收藏/评论)") yg_box.pack(fill=X, padx=10, pady=(10, 10)) yg_switch = ttk.Frame(yg_box) yg_switch.pack(fill=X, padx=10, pady=(10, 6)) ttk.Checkbutton( yg_switch, text="养号总开关(关闭则跳过推荐页养号)", variable=yg_enabled_var ).pack(side=LEFT) ttk.Checkbutton( yg_switch, text="启用养号动作(爱心/收藏/评论)", variable=yg_actions_enabled_var, ).pack(side=LEFT, padx=(10, 0)) ttk.Checkbutton( yg_switch, text="只养号(仅执行推荐页养号,跳过抽奖/参与)", variable=yg_only_var, ).pack(side=LEFT, padx=(10, 0)) yg0 = ttk.Frame(yg_box) yg0.pack(fill=X, padx=10, pady=(0, 8)) ttk.Checkbutton( yg0, text="逐步截图(调试用,生成 pic/*/latest.png)", variable=yg_step_screenshot_var, ).pack(side=LEFT) yg_time = ttk.Frame(yg_box) yg_time.pack(fill=X, padx=10, pady=(0, 8)) ttk.Label(yg_time, text="养号时长(秒):").pack(side=LEFT) ttk.Spinbox( yg_time, from_=1, to=3600, increment=5, textvariable=yg_recommend_duration_var, width=8, ).pack(side=LEFT) ttk.Label(yg_time, text="养号间隔(秒):").pack(side=LEFT, padx=(12, 0)) ttk.Spinbox( yg_time, from_=0, to=3600, increment=10, textvariable=yg_recommend_interval_var, width=8, ).pack(side=LEFT) ttk.Label(yg_time, text="(0=每次触发都执行)").pack(side=LEFT, padx=(6, 0)) yg1 = ttk.Frame(yg_box) yg1.pack(fill=X, padx=10, pady=(0, 8)) ttk.Label(yg1, text="爱心概率:").pack(side=LEFT) ttk.Spinbox( yg1, from_=0.0, to=1.0, increment=0.05, textvariable=yg_like_prob_var, width=6 ).pack(side=LEFT) ttk.Label(yg1, text="收藏概率:").pack(side=LEFT, padx=(10, 0)) ttk.Spinbox( yg1, from_=0.0, to=1.0, increment=0.05, textvariable=yg_fav_prob_var, width=6 ).pack(side=LEFT) ttk.Label(yg1, text="评论概率:").pack(side=LEFT, padx=(10, 0)) ttk.Spinbox( yg1, from_=0.0, to=1.0, increment=0.05, textvariable=yg_comment_prob_var, width=6, ).pack(side=LEFT) ttk.Label(yg1, text="(0~1)").pack(side=LEFT, padx=(6, 0)) yg2 = ttk.Frame(yg_box) yg2.pack(fill=X, padx=10, pady=(0, 8)) ttk.Label(yg2, text="图标ROI大小(px):").pack(side=LEFT) ttk.Spinbox( yg2, from_=80, to=600, increment=10, textvariable=yg_icon_roi_size_var, width=6 ).pack(side=LEFT) ttk.Label(yg2, text="匹配阈值:").pack(side=LEFT, padx=(10, 0)) ttk.Spinbox( yg2, from_=0.0, to=1.0, increment=0.01, textvariable=yg_icon_match_threshold_var, width=6, ).pack(side=LEFT) yg_texts = ttk.Frame(yg_box) yg_texts.pack(fill=BOTH, expand=True, padx=10, pady=(0, 10)) ttk.Label(yg_texts, text="评论文案库(每行一条):").pack(anchor="w") yg_comment_texts = ScrolledText(yg_texts, height=4) yg_comment_texts.pack(fill=X, pady=(0, 6)) yg_kw = ttk.Frame(yg_texts) yg_kw.pack(fill=BOTH, expand=True) ttk.Label(yg_kw, text="爱心关键词(每行一条):").pack(anchor="w") yg_like_keywords_text = ScrolledText(yg_kw, height=3) yg_like_keywords_text.pack(fill=X, pady=(0, 6)) ttk.Label(yg_kw, text="收藏关键词(每行一条):").pack(anchor="w") yg_fav_keywords_text = ScrolledText(yg_kw, height=3) yg_fav_keywords_text.pack(fill=X) quiet_box = ttk.LabelFrame(yanghao_tab, text="定时禁抢(仅养号)") quiet_box.pack(fill=X, padx=10, pady=(0, 10)) quiet_r0 = ttk.Frame(quiet_box) quiet_r0.pack(fill=X, padx=10, pady=(10, 6)) ttk.Checkbutton( quiet_r0, text="启用定时禁抢", variable=fudai_quiet_hours_enabled_var ).pack(side=LEFT) quiet_r1 = ttk.Frame(quiet_box) quiet_r1.pack(fill=X, padx=10, pady=(0, 10)) ttk.Label(quiet_r1, text="开始小时:").pack(side=LEFT) ttk.Spinbox( quiet_r1, from_=0, to=23, textvariable=fudai_quiet_start_hour_var, width=6 ).pack(side=LEFT) ttk.Label(quiet_r1, text="结束小时:").pack(side=LEFT, padx=(12, 0)) ttk.Spinbox( quiet_r1, from_=0, to=23, textvariable=fudai_quiet_end_hour_var, width=6 ).pack(side=LEFT) # 标签页5:调试参数 debug_tab = ttk.Frame(left_notebook) # 为调试参数标签页添加滚动条 debug_canvas = tk.Canvas(debug_tab, highlightthickness=0) debug_scrollbar = ttk.Scrollbar( debug_tab, orient="vertical", command=debug_canvas.yview ) debug_scrollable_frame = ttk.Frame(debug_canvas) debug_scrollable_frame.bind( "", lambda e: debug_canvas.configure(scrollregion=debug_canvas.bbox("all")), ) debug_canvas.create_window((0, 0), window=debug_scrollable_frame, anchor="nw") debug_canvas.configure(yscrollcommand=debug_scrollbar.set) # 鼠标滚轮支持 def _on_mousewheel(event): debug_canvas.yview_scroll(int(-1 * (event.delta / 120)), "units") def _on_shift_mousewheel(event): debug_canvas.xview_scroll(int(-1 * (event.delta / 120)), "units") debug_canvas.bind_all("", _on_mousewheel) debug_canvas.bind_all("", _on_shift_mousewheel) debug_canvas.pack(side="left", fill="both", expand=True) debug_scrollbar.pack(side="right", fill="y") left_notebook.add(debug_tab, text="调试参数") # 使用scrollable_frame作为容器 debug_container = debug_scrollable_frame # 调试图像 debug_captures_box = ttk.LabelFrame(debug_container, text="调试图像") debug_captures_box.pack(fill=X, padx=10, pady=(10, 10)) debug_r0 = ttk.Frame(debug_captures_box) debug_r0.pack(fill=X, padx=10, pady=(10, 8)) ttk.Checkbutton( debug_r0, text="保存调试图像(OCR / 像素 / 模板等)", variable=debug_captures_enabled_var, ).pack(side=LEFT) ttk.Checkbutton( debug_r0, text="异步保存调试图像(默认启用)", variable=debug_captures_async_save_var, ).pack(side=LEFT, padx=(10, 0)) ttk.Checkbutton( debug_r0, text="保存完成后记录日志(显示路径)", variable=debug_captures_log_on_complete_var, ).pack(side=LEFT, padx=(10, 0)) # 异步保存计数显示与重置 debug_counts_frame = ttk.Frame(debug_r0) debug_counts_frame.pack(side=LEFT, padx=(10, 0)) ttk.Label(debug_counts_frame, text="异步保存:").pack(side=LEFT) ttk.Label( debug_counts_frame, textvariable=debug_async_success_var, foreground="green" ).pack(side=LEFT, padx=(4, 8)) ttk.Label(debug_counts_frame, text="/").pack(side=LEFT) ttk.Label( debug_counts_frame, textvariable=debug_async_failure_var, foreground="red" ).pack(side=LEFT, padx=(4, 8)) def on_reset_async_counters(): try: import importlib douyin_screenshot_manager = importlib.import_module( "douyin.handlers.douyin_screenshot_manager" ) douyin_screenshot_manager.reset_async_save_counters() debug_async_success_var.set(0) debug_async_failure_var.set(0) except Exception: pass ttk.Button( debug_counts_frame, text="重置", command=on_reset_async_counters, width=6 ).pack(side=LEFT, padx=(6, 0)) # 周期性更新计数器(2秒) def _update_async_counters(): try: import importlib douyin_screenshot_manager = importlib.import_module( "douyin.handlers.douyin_screenshot_manager" ) s, f = douyin_screenshot_manager.get_async_save_counters() debug_async_success_var.set(s) debug_async_failure_var.set(f) except Exception: pass try: debug_r0.after(2000, _update_async_counters) except Exception: pass # 启动更新循环 try: _update_async_counters() except Exception: pass debug_cleanup_box = ttk.LabelFrame(debug_container, text="调试图像清理") debug_cleanup_box.pack(fill=X, padx=10, pady=(0, 10)) debug_r1 = ttk.Frame(debug_cleanup_box) debug_r1.pack(fill=X, padx=10, pady=(10, 8)) ttk.Checkbutton( debug_r1, text="启用自动清理调试图像", variable=debug_captures_auto_cleanup_var ).pack(side=LEFT) debug_r2 = ttk.Frame(debug_cleanup_box) debug_r2.pack(fill=X, padx=10, pady=(0, 8)) ttk.Label(debug_r2, text="保留天数:").pack(side=LEFT) ttk.Spinbox( debug_r2, from_=1, to=30, increment=1, textvariable=debug_captures_keep_days_var, width=6, ).pack(side=LEFT) ttk.Label(debug_r2, text="最大文件数量:").pack(side=LEFT, padx=(20, 0)) ttk.Spinbox( debug_r2, from_=100, to=10000, increment=100, textvariable=debug_captures_max_files_var, width=8, ).pack(side=LEFT) ttk.Label(debug_r2, text="(超过此数量自动清理)").pack(side=LEFT, padx=(6, 0)) # 找福袋参数 fudai_find_box = ttk.LabelFrame(debug_container, text="找福袋参数") fudai_find_box.pack(fill=X, padx=10, pady=(0, 10)) row4 = ttk.Frame(fudai_find_box) row4.pack(fill=X, padx=10, pady=(10, 8)) ttk.Label(row4, text="找福袋最大尝试次数:").pack(side=LEFT) ttk.Spinbox( row4, from_=0, to=50, increment=1, textvariable=fudai_find_max_attempts_var, width=6, ).pack(side=LEFT) ttk.Label(row4, text="(0=使用默认值)").pack(side=LEFT, padx=(6, 0)) row4b = ttk.Frame(fudai_find_box) row4b.pack(fill=X, padx=10, pady=(0, 8)) ttk.Label(row4b, text="找福袋重试间隔(秒):").pack(side=LEFT) ttk.Spinbox( row4b, from_=0.1, to=3.0, increment=0.1, textvariable=fudai_icon_retry_delay_seconds_var, width=6, ).pack(side=LEFT) ttk.Label(row4b, text=" 最大等待时间(秒):").pack(side=LEFT, padx=(10, 0)) ttk.Spinbox( row4b, from_=0.0, to=30.0, increment=0.5, textvariable=fudai_icon_max_wait_seconds_var, width=6, ).pack(side=LEFT) ttk.Label(row4b, text="(实际识别常见 4-6 秒)").pack(side=LEFT, padx=(6, 0)) row4d = ttk.Frame(fudai_find_box) row4d.pack(fill=X, padx=10, pady=(0, 8)) ttk.Label(row4d, text="点击福袋后等待时间(秒):").pack(side=LEFT) ttk.Spinbox( row4d, from_=0.5, to=10.0, increment=0.1, textvariable=fudai_click_wait_seconds_var, width=6, ).pack(side=LEFT) ttk.Label(row4d, text="(等待福袋详情页加载,默认1.0秒)").pack( side=LEFT, padx=(6, 0) ) row4c = ttk.Frame(fudai_find_box) row4c.pack(fill=X, padx=10, pady=(0, 8)) ttk.Checkbutton( row4c, text="禁用福袋内容OCR识别", variable=fudai_disable_content_recognition_var, onvalue=True, offvalue=False, ).pack(side=LEFT) ttk.Label(row4c, text="(仅影响 content OCR,不改其它识别模块)").pack( side=LEFT, padx=(6, 0) ) # 任务列表 OCR 开关 ttk.Checkbutton( row4c, text="禁用福袋任务列表OCR识别", variable=fudai_disable_task_recognition_var, onvalue=True, offvalue=False, ).pack(side=LEFT, padx=(12, 0)) row4e = ttk.Frame(fudai_find_box) row4e.pack(fill=X, padx=10, pady=(0, 8)) ttk.Label(row4e, text="切换直播间后等待时间(秒):").pack(side=LEFT) ttk.Spinbox( row4e, from_=0.0, to=30.0, increment=0.5, textvariable=switch_room_wait_after_stage_diag_seconds_var, width=6, ).pack(side=LEFT) ttk.Label(row4e, text="(阶段检测后等待福袋加载,默认7.0秒)").pack( side=LEFT, padx=(6, 0) ) row4f = ttk.Frame(fudai_find_box) row4f.pack(fill=X, padx=10, pady=(0, 8)) ttk.Label(row4f, text="滑动速度(毫秒):").pack(side=LEFT) ttk.Spinbox( row4f, from_=100, to=2000, increment=50, textvariable=swipe_duration_ms_var, width=6, ).pack(side=LEFT) ttk.Label(row4f, text="(滑动持续时间,默认600ms,值越大滑动越慢)").pack( side=LEFT, padx=(6, 0) ) row4c = ttk.Frame(fudai_find_box) row4c.pack(fill=X, padx=10, pady=(0, 10)) ttk.Label(row4c, text="直播间检测阈值(白色像素比例):").pack(side=LEFT) ttk.Spinbox( row4c, from_=0.0, to=1.0, increment=0.01, textvariable=live_room_match_threshold_var, width=6, ).pack(side=LEFT) ttk.Label( row4c, text="(0.0~1.0,默认0.8,多边形区域白色像素比例>=此值判定为在直播间)" ).pack(side=LEFT, padx=(6, 0)) # 阶段诊断时间参数(用于调试) diag_time_box = ttk.LabelFrame(debug_container, text="阶段诊断时间参数") diag_time_box.pack(fill=X, padx=10, pady=(0, 10)) diag_time_r1 = ttk.Frame(diag_time_box) diag_time_r1.pack(fill=X, padx=10, pady=(10, 6)) ttk.Label(diag_time_r1, text="最大诊断时间(秒):").pack(side=LEFT) ttk.Spinbox( diag_time_r1, from_=1.0, to=60.0, increment=1.0, textvariable=stage_diag_max_time_var, width=8, ).pack(side=LEFT) ttk.Label(diag_time_r1, text="每步最大耗时(秒):").pack(side=LEFT, padx=(12, 0)) ttk.Spinbox( diag_time_r1, from_=0.5, to=30.0, increment=0.5, textvariable=stage_diag_max_step_time_var, width=8, ).pack(side=LEFT) ttk.Label(diag_time_r1, text="(用于调试,延长检测时间)").pack( side=LEFT, padx=(6, 0) ) diag_time_r2 = ttk.Frame(diag_time_box) diag_time_r2.pack(fill=X, padx=10, pady=(0, 6)) ttk.Checkbutton( diag_time_r2, text="启用OCR模式1(二值化)", variable=enable_ocr_mode1_var ).pack(side=LEFT) diag_time_r2b = ttk.Frame(diag_time_box) diag_time_r2b.pack(fill=X, padx=10, pady=(0, 6)) ttk.Checkbutton( diag_time_r2b, text="启用福袋模板匹配", variable=fudai_template_match_enabled_var, ).pack(side=LEFT) diag_time_r3 = ttk.Frame(diag_time_box) diag_time_r3.pack(fill=X, padx=10, pady=(0, 10)) ttk.Label(diag_time_r3, text="福袋模板匹配阈值:").pack(side=LEFT) ttk.Spinbox( diag_time_r3, from_=0.0, to=1.0, increment=0.01, textvariable=fudai_template_match_threshold_var, width=8, ).pack(side=LEFT) ttk.Label(diag_time_r3, text="(0.0-1.0,彩色匹配)").pack(side=LEFT, padx=(6, 0)) diag_time_r3b = ttk.Frame(diag_time_box) diag_time_r3b.pack(fill=X, padx=10, pady=(0, 10)) ttk.Label(diag_time_r3b, text="福袋详情页模板匹配阈值:").pack(side=LEFT) ttk.Spinbox( diag_time_r3b, from_=0.0, to=1.0, increment=0.01, textvariable=fudai_detail_template_threshold_var, width=8, ).pack(side=LEFT) ttk.Label( diag_time_r3b, text="(0.0-1.0,默认0.7,区域(398,894)-(658,1179))" ).pack(side=LEFT, padx=(6, 0)) diag_time_r4 = ttk.Frame(diag_time_box) diag_time_r4.pack(fill=X, padx=10, pady=(0, 10)) ttk.Label(diag_time_r4, text="开奖页红色占比阈值:").pack(side=LEFT) ttk.Spinbox( diag_time_r4, from_=0.0, to=1.0, increment=0.01, textvariable=lucky_draw_red_ratio_threshold_var, width=8, ).pack(side=LEFT) ttk.Label(diag_time_r4, text="(默认0.90,≥此占比判定开奖页)").pack( side=LEFT, padx=(6, 0) ) # 更多模板匹配阈值 diag_time_r5 = ttk.Frame(diag_time_box) diag_time_r5.pack(fill=X, padx=10, pady=(0, 6)) ttk.Label(diag_time_r5, text="优惠券模板匹配阈值:").pack(side=LEFT) ttk.Spinbox( diag_time_r5, from_=0.0, to=1.0, increment=0.01, textvariable=coupon_template_match_threshold_var, width=8, ).pack(side=LEFT) ttk.Label(diag_time_r5, text="(默认0.75,用于检测优惠券弹窗)").pack( side=LEFT, padx=(6, 0) ) # 像素检测阈值 pixel_detect_box = ttk.LabelFrame(debug_container, text="像素检测阈值") pixel_detect_box.pack(fill=X, padx=10, pady=(0, 10)) pixel_r1 = ttk.Frame(pixel_detect_box) pixel_r1.pack(fill=X, padx=10, pady=(10, 6)) ttk.Label(pixel_r1, text="参与按钮红色占比阈值:").pack(side=LEFT) ttk.Spinbox( pixel_r1, from_=0.0, to=1.0, increment=0.01, textvariable=attend_button_red_ratio_threshold_var, width=8, ).pack(side=LEFT) ttk.Label(pixel_r1, text="(默认0.25,用于检测参与按钮)").pack( side=LEFT, padx=(6, 0) ) pixel_r2 = ttk.Frame(pixel_detect_box) pixel_r2.pack(fill=X, padx=10, pady=(0, 10)) ttk.Label(pixel_r2, text="粉丝团加入红色占比阈值:").pack(side=LEFT) ttk.Spinbox( pixel_r2, from_=0.0, to=1.0, increment=0.01, textvariable=fansclub_join_red_ratio_threshold_var, width=8, ).pack(side=LEFT) ttk.Label(pixel_r2, text="(默认0.25,用于检测粉丝团加入按钮)").pack( side=LEFT, padx=(6, 0) ) # 日志配置 logging_config_box = ttk.LabelFrame(debug_container, text="日志配置") logging_config_box.pack(fill=X, padx=10, pady=(0, 10)) # 日志美化选项 log_r1 = ttk.Frame(logging_config_box) log_r1.pack(fill=X, padx=10, pady=(10, 6)) ttk.Checkbutton( log_r1, text="启用日志美化", variable=logging_beautify_var, ).pack(side=LEFT) ttk.Checkbutton( log_r1, text="启用颜色显示", variable=logging_color_var, ).pack(side=LEFT, padx=(20, 0)) # 日志详细程度 log_r2 = ttk.Frame(logging_config_box) log_r2.pack(fill=X, padx=10, pady=(0, 6)) ttk.Label(log_r2, text="调试日志详细程度:").pack(side=LEFT) ttk.Combobox( log_r2, values=["normal", "detailed", "minimal"], textvariable=logging_debug_level_var, state="readonly", width=10, ).pack(side=LEFT, padx=(0, 20)) ttk.Label(log_r2, text="错误日志详细程度:").pack(side=LEFT) ttk.Combobox( log_r2, values=["full", "basic", "minimal"], textvariable=logging_error_level_var, state="readonly", width=10, ).pack(side=LEFT) # 行为日志格式 log_r3 = ttk.Frame(logging_config_box) log_r3.pack(fill=X, padx=10, pady=(0, 6)) ttk.Label(log_r3, text="行为日志格式:").pack(side=LEFT) ttk.Combobox( log_r3, values=["concise", "detailed", "minimal"], textvariable=logging_action_format_var, state="readonly", width=10, ).pack(side=LEFT, padx=(0, 20)) ttk.Checkbutton( log_r3, text="显示时间戳", variable=logging_show_timestamps_var, ).pack(side=LEFT, padx=(20, 0)) # 界面主题选择 log_theme_row = ttk.Frame(logging_config_box) log_theme_row.pack(fill=X, padx=10, pady=(6, 10)) ttk.Label(log_theme_row, text="界面主题:").pack(side=LEFT) ttk.Combobox( log_theme_row, values=["litera", "flatly", "journal", "minty", "cosmo", "darkly"], textvariable=gui_theme_var, state="readonly", width=12, ).pack(side=LEFT, padx=(6, 0)) ttk.Label(log_theme_row, text="(更改后请保存并重启以完全应用主题)").pack( side=LEFT, padx=(12, 0) ) # 性能追踪 log_r4 = ttk.Frame(logging_config_box) log_r4.pack(fill=X, padx=10, pady=(0, 10)) perf_frame = ttk.LabelFrame(log_r4, text="性能追踪") perf_frame.pack(fill=X, pady=(0, 0)) ttk.Checkbutton( perf_frame, text="启用性能追踪", variable=logging_performance_enabled_var, ).pack(side=LEFT, padx=10, pady=5) ttk.Checkbutton( perf_frame, text="追踪函数调用", variable=logging_track_functions_var, ).pack(side=LEFT, padx=(20, 0), pady=5) # 流式后台截图开关(GUI 控制) ttk.Checkbutton( perf_frame, text="启用流式后台截图(加速但可能导致并发读取)", variable=streaming_enabled_var, ).pack(side=LEFT, padx=(20, 0), pady=5) # 标签页6:关键词 keywords_tab = ttk.Frame(left_notebook) left_notebook.add(keywords_tab, text="关键词") kw_box = ttk.LabelFrame(keywords_tab, text="关键词(每行一个,仅黑名单)") kw_box.pack(fill=BOTH, expand=True, padx=10, pady=(10, 10)) ttk.Label(kw_box, text="不想要 contains_not_want(黑名单)").pack( anchor="w", padx=10, pady=(10, 4) ) not_want_text = ScrolledText(kw_box, height=8) not_want_text.pack(fill=X, padx=10, pady=(0, 10)) def load_config_to_ui(): nonlocal cfg cfg = read_config() needswitch_var.set(bool(cfg.get("needswitch", True))) infinite_loop_var.set(bool(cfg.get("infinite_loop_enabled", False))) wait_minutes_var.set(int(cfg.get("wait_minutes", 5) or 5)) yg_enabled_var.set(bool(cfg.get("yanghao_enabled", True))) yg_actions_enabled_var.set(bool(cfg.get("yanghao_enable_actions", True))) yg_only_var.set(bool(cfg.get("yanghao_only", False))) yg_recommend_duration_var.set( int(cfg.get("yanghao_recommend_duration_seconds", 60) or 60) ) yg_recommend_interval_var.set( int(cfg.get("yanghao_recommend_interval_seconds", 0) or 0) ) min_value_var.set(float(cfg.get("min_prize_value_yuan", 0) or 0)) min_participants_var.set(int(cfg.get("min_participants", 0) or 0)) max_participants_var.set(int(cfg.get("max_participants", 0) or 0)) skip_gt_seconds_var.set( int(cfg.get("skip_if_countdown_gt_seconds", 900) or 900) ) reset_after_swipes_enabled_var.set( bool(cfg.get("reset_after_swipes_enabled", False)) ) reset_after_swipes_var.set(int(cfg.get("reset_after_swipes", 10) or 10)) auto_join_var.set(bool(cfg.get("auto_join_fansclub", False))) fansclub_action_var.set( str(cfg.get("fansclub_fail_action", "stay") or "stay").lower() ) streaming_enabled_var.set(bool(cfg.get("enable_streaming_screenshot", True))) lucky_draw_red_ratio_threshold_var.set( float(cfg.get("lucky_draw_red_ratio_threshold", 0.9) or 0.9) ) y_var.set(int(cfg.get("y_pianyi", 0) or 0)) # Web端新增配置 - 高价值预约相关 high_value_fudai_enabled_var.set( bool(cfg.get("high_value_fudai_enabled", False)) ) high_value_fudai_threshold_yuan_var.set( float(cfg.get("high_value_fudai_threshold_yuan", 1000) or 1000) ) high_value_fudai_join_ahead_seconds_var.set( int(cfg.get("high_value_fudai_join_ahead_seconds", 120) or 120) ) high_value_fudai_max_swipe_back_var.set( int(cfg.get("high_value_fudai_max_swipe_back", 60) or 60) ) high_value_fudai_max_reservations_var.set( int(cfg.get("high_value_fudai_max_reservations", 5) or 5) ) high_value_fudai_after_action_var.set( str(cfg.get("high_value_fudai_after_action", "continue") or "continue") ) high_value_room_revisit_enabled_var.set( bool(cfg.get("high_value_room_revisit_enabled", True)) ) high_value_room_revisit_only_current_run_var.set( bool(cfg.get("high_value_room_revisit_only_current_run", False)) ) reservation_back_verify_enabled_var.set( bool(cfg.get("reservation_back_verify_enabled", True)) ) reservation_back_swipe_delay_var.set( float(cfg.get("reservation_back_swipe_delay", 0) or 0) ) reservation_preempt_min_value_var.set( float(cfg.get("reservation_preempt_min_value", 0) or 0) ) fudai_find_max_attempts_var.set(int(cfg.get("fudai_find_max_attempts", 0) or 0)) fudai_icon_retry_delay_seconds_var.set( float(cfg.get("fudai_icon_retry_delay_seconds", 0.6) or 0.6) ) fudai_icon_max_wait_seconds_var.set( float(cfg.get("fudai_icon_max_wait_seconds", 5.0) or 5.0) ) fudai_click_wait_seconds_var.set( float(cfg.get("fudai_click_wait_seconds", 1.0) or 1.0) ) fudai_disable_content_recognition_var.set( bool(cfg.get("fudai_disable_content_recognition", False)) ) fudai_disable_task_recognition_var.set( bool(cfg.get("fudai_disable_task_recognition", False)) ) try: fudai_exit_after_misses_var.set( int(cfg.get("fudai_exit_after_misses", 30) or 30) ) except Exception: fudai_exit_after_misses_var.set(30) switch_room_wait_after_stage_diag_seconds_var.set( float(cfg.get("switch_room_wait_after_stage_diag_seconds", 7.0) or 7.0) ) # GUI 主题 try: gui_theme_var.set( str(cfg.get("gui", {}).get("theme", "litera") or "litera") ) except Exception: gui_theme_var.set("litera") live_room_match_threshold_var.set( float(cfg.get("live_room_match_threshold", 0.8) or 0.8) ) swipe_duration_ms_var.set(int(cfg.get("swipe_duration_ms", 600) or 600)) fudai_quiet_hours_enabled_var.set( bool(cfg.get("fudai_quiet_hours_enabled", True)) ) fudai_quiet_start_hour_var.set(int(cfg.get("fudai_quiet_start_hour", 2) or 2)) fudai_quiet_end_hour_var.set(int(cfg.get("fudai_quiet_end_hour", 7) or 7)) stage_diag_max_time_var.set(float(cfg.get("stage_diag_max_time", 10.0) or 10.0)) stage_diag_max_step_time_var.set( float(cfg.get("stage_diag_max_step_time", 2.0) or 2.0) ) enable_ocr_mode1_var.set(bool(cfg.get("enable_ocr_mode1", False))) fudai_template_match_enabled_var.set( bool(cfg.get("fudai_template_match_enabled", False)) ) fudai_template_match_threshold_var.set( float(cfg.get("fudai_template_match_threshold", 0.7) or 0.7) ) fudai_detail_template_threshold_var.set( float(cfg.get("fudai_detail_template_threshold", 0.7) or 0.7) ) coupon_template_match_threshold_var.set( float(cfg.get("coupon_template_match_threshold", 0.75) or 0.75) ) attend_button_red_ratio_threshold_var.set( float(cfg.get("attend_button_red_ratio_threshold", 0.25) or 0.25) ) fansclub_join_red_ratio_threshold_var.set( float(cfg.get("fansclub_join_red_ratio_threshold", 0.25) or 0.25) ) # 粉丝团等待/点击延迟配置 fansclub_click_delay_var.set(float(cfg.get("fansclub_click_delay", 0.6) or 0.6)) fansclub_auto_wait_var.set( float(cfg.get("fansclub_auto_join_wait_seconds", 5.0) or 5.0) ) fansclub_manual_wait_var.set( float(cfg.get("fansclub_manual_wait_seconds", 3.0) or 3.0) ) skip_lt_seconds_var.set(int(cfg.get("skip_if_countdown_lt_seconds", 10) or 10)) # 调试图像清理配置 debug_captures_config = cfg.get("debug_captures", {}) if isinstance(debug_captures_config, dict): debug_captures_enabled_var.set( bool(debug_captures_config.get("enabled", False)) ) debug_captures_auto_cleanup_var.set( bool(debug_captures_config.get("auto_cleanup", True)) ) debug_captures_keep_days_var.set( int(debug_captures_config.get("keep_days", 7) or 7) ) debug_captures_max_files_var.set( int(debug_captures_config.get("max_files", 2000) or 2000) ) debug_captures_async_save_var.set( bool(debug_captures_config.get("async_save", True)) ) debug_captures_log_on_complete_var.set( bool(debug_captures_config.get("log_on_complete", False)) ) else: debug_captures_auto_cleanup_var.set(True) debug_captures_keep_days_var.set(7) debug_captures_max_files_var.set(2000) yg_like_prob_var.set(float(cfg.get("yanghao_like_prob", 0.0) or 0.0)) yg_fav_prob_var.set(float(cfg.get("yanghao_fav_prob", 0.0) or 0.0)) yg_comment_prob_var.set(float(cfg.get("yanghao_comment_prob", 0.0) or 0.0)) yg_icon_roi_size_var.set(int(cfg.get("yanghao_icon_roi_size", 240) or 240)) yg_icon_match_threshold_var.set( float(cfg.get("yanghao_icon_match_threshold", 0.72) or 0.72) ) yg_step_screenshot_var.set(bool(cfg.get("yanghao_step_screenshot", False))) yg_like_roi_offset_x_var.set(int(cfg.get("yanghao_like_roi_offset_x", 0) or 0)) yg_like_roi_offset_y_var.set(int(cfg.get("yanghao_like_roi_offset_y", 0) or 0)) yg_fav_roi_offset_x_var.set(int(cfg.get("yanghao_fav_roi_offset_x", 0) or 0)) yg_fav_roi_offset_y_var.set(int(cfg.get("yanghao_fav_roi_offset_y", 0) or 0)) yg_like_icon_x_var.set(int(cfg.get("yanghao_like_icon_x", 0) or 0)) yg_like_icon_y_var.set(int(cfg.get("yanghao_like_icon_y", 0) or 0)) yg_fav_icon_x_var.set(int(cfg.get("yanghao_fav_icon_x", 0) or 0)) yg_fav_icon_y_var.set(int(cfg.get("yanghao_fav_icon_y", 0) or 0)) yg_like_template_path_var.set( str( cfg.get("yanghao_like_template_path", "assets/like.png") or "assets/like.png" ) ) yg_fav_template_path_var.set( str( cfg.get("yanghao_fav_template_path", "assets/fav.png") or "assets/fav.png" ) ) yg_after_dwell_direction_var.set( str(cfg.get("yanghao_after_dwell_swipe_direction", "up") or "up") ) yg_after_dwell_distance_var.set( int(cfg.get("yanghao_after_dwell_swipe_distance_px", 900) or 900) ) yg_comment_btn_x_var.set(int(cfg.get("yanghao_comment_btn_x", 0) or 0)) yg_comment_btn_y_var.set(int(cfg.get("yanghao_comment_btn_y", 0) or 0)) yg_comment_input_x_var.set(int(cfg.get("yanghao_comment_input_x", 0) or 0)) yg_comment_input_y_var.set(int(cfg.get("yanghao_comment_input_y", 0) or 0)) yg_comment_send_x_var.set(int(cfg.get("yanghao_comment_send_x", 0) or 0)) yg_comment_send_y_var.set(int(cfg.get("yanghao_comment_send_y", 0) or 0)) yg_comment_close_x_var.set(int(cfg.get("yanghao_comment_close_x", 0) or 0)) yg_comment_close_y_var.set(int(cfg.get("yanghao_comment_close_y", 0) or 0)) # 仅保留黑名单 contains_not_want not_want = cfg.get("contains_not_want", []) or [] yg_comment_texts_list = cfg.get("yanghao_comment_texts", []) or [] yg_like_keywords_list = cfg.get("yanghao_like_keywords", []) or [] yg_fav_keywords_list = cfg.get("yanghao_fav_keywords", []) or [] not_want_text.delete("1.0", "end") not_want_text.insert("1.0", "\n".join(not_want)) yg_comment_texts.delete("1.0", "end") yg_comment_texts.insert("1.0", "\n".join(yg_comment_texts_list)) yg_like_keywords_text.delete("1.0", "end") yg_like_keywords_text.insert("1.0", "\n".join(yg_like_keywords_list)) yg_fav_keywords_text.delete("1.0", "end") yg_fav_keywords_text.insert("1.0", "\n".join(yg_fav_keywords_list)) def save_ui_to_config(): # 仅保存黑名单 contains_not_want not_want_lines = [ x.strip() for x in not_want_text.get("1.0", "end").splitlines() if x.strip() ] yg_comment_text_lines = [ x.strip() for x in yg_comment_texts.get("1.0", "end").splitlines() if x.strip() ] yg_like_kw_lines = [ x.strip() for x in yg_like_keywords_text.get("1.0", "end").splitlines() if x.strip() ] yg_fav_kw_lines = [ x.strip() for x in yg_fav_keywords_text.get("1.0", "end").splitlines() if x.strip() ] cfg2 = read_config() cfg2["needswitch"] = bool(needswitch_var.get()) cfg2["infinite_loop_enabled"] = bool(infinite_loop_var.get()) cfg2["wait_minutes"] = int(wait_minutes_var.get() or 5) cfg2["y_pianyi"] = int(y_var.get() or 0) cfg2["contains_not_want"] = not_want_lines cfg2["min_prize_value_yuan"] = float(min_value_var.get() or 0) cfg2["min_participants"] = int(min_participants_var.get() or 0) cfg2["max_participants"] = int(max_participants_var.get() or 0) cfg2["skip_if_countdown_gt_seconds"] = int(skip_gt_seconds_var.get() or 900) cfg2["reset_after_swipes_enabled"] = bool(reset_after_swipes_enabled_var.get()) cfg2["reset_after_swipes"] = int(reset_after_swipes_var.get() or 10) cfg2["auto_join_fansclub"] = bool(auto_join_var.get()) cfg2["fansclub_fail_action"] = str(fansclub_action_var.get() or "stay").lower() cfg2["lucky_draw_red_ratio_threshold"] = float( lucky_draw_red_ratio_threshold_var.get() or 0.9 ) # Web端新增配置 - 高价值预约相关 cfg2["high_value_fudai_enabled"] = bool(high_value_fudai_enabled_var.get()) cfg2["high_value_fudai_threshold_yuan"] = float( high_value_fudai_threshold_yuan_var.get() or 1000 ) cfg2["high_value_fudai_join_ahead_seconds"] = int( high_value_fudai_join_ahead_seconds_var.get() or 120 ) cfg2["high_value_fudai_max_swipe_back"] = int( high_value_fudai_max_swipe_back_var.get() or 60 ) cfg2["high_value_fudai_max_reservations"] = int( high_value_fudai_max_reservations_var.get() or 5 ) cfg2["high_value_fudai_after_action"] = str( high_value_fudai_after_action_var.get() or "continue" ).lower() cfg2["high_value_room_revisit_enabled"] = bool( high_value_room_revisit_enabled_var.get() ) cfg2["high_value_room_revisit_only_current_run"] = bool( high_value_room_revisit_only_current_run_var.get() ) cfg2["reservation_back_verify_enabled"] = bool( reservation_back_verify_enabled_var.get() ) cfg2["reservation_back_swipe_delay"] = float( reservation_back_swipe_delay_var.get() or 0 ) cfg2["reservation_preempt_min_value"] = float( reservation_preempt_min_value_var.get() or 0 ) cfg2["fudai_find_max_attempts"] = int(fudai_find_max_attempts_var.get() or 0) cfg2["fudai_icon_retry_delay_seconds"] = float( fudai_icon_retry_delay_seconds_var.get() or 0.6 ) cfg2["fudai_icon_max_wait_seconds"] = float( fudai_icon_max_wait_seconds_var.get() or 5.0 ) cfg2["fudai_click_wait_seconds"] = float( fudai_click_wait_seconds_var.get() or 2.0 ) cfg2["fudai_exit_after_misses"] = int(fudai_exit_after_misses_var.get() or 30) cfg2["fudai_disable_content_recognition"] = bool( fudai_disable_content_recognition_var.get() ) cfg2["fudai_disable_task_recognition"] = bool( fudai_disable_task_recognition_var.get() ) cfg2["switch_room_wait_after_stage_diag_seconds"] = float( switch_room_wait_after_stage_diag_seconds_var.get() or 7.0 ) cfg2["live_room_match_threshold"] = float( live_room_match_threshold_var.get() or 0.8 ) cfg2["swipe_duration_ms"] = int(swipe_duration_ms_var.get() or 600) cfg2["fudai_quiet_hours_enabled"] = bool(fudai_quiet_hours_enabled_var.get()) cfg2["fudai_quiet_start_hour"] = int(fudai_quiet_start_hour_var.get() or 0) cfg2["fudai_quiet_end_hour"] = int(fudai_quiet_end_hour_var.get() or 0) cfg2["stage_diag_max_time"] = float(stage_diag_max_time_var.get() or 10.0) cfg2["stage_diag_max_step_time"] = float( stage_diag_max_step_time_var.get() or 2.0 ) cfg2["enable_ocr_mode1"] = bool(cfg.get("enable_ocr_mode1", False)) cfg2["fudai_template_match_enabled"] = bool( fudai_template_match_enabled_var.get() ) cfg2["fudai_template_match_threshold"] = float( fudai_template_match_threshold_var.get() or 0.7 ) cfg2["fudai_detail_template_threshold"] = float( fudai_detail_template_threshold_var.get() or 0.7 ) cfg2["coupon_template_match_threshold"] = float( coupon_template_match_threshold_var.get() or 0.75 ) cfg2["attend_button_red_ratio_threshold"] = float( attend_button_red_ratio_threshold_var.get() or 0.25 ) cfg2["fansclub_join_red_ratio_threshold"] = float( fansclub_join_red_ratio_threshold_var.get() or 0.25 ) # 粉丝团等待/点击延迟配置 cfg2["fansclub_click_delay"] = float(fansclub_click_delay_var.get() or 0.6) cfg2["fansclub_auto_join_wait_seconds"] = float( fansclub_auto_wait_var.get() or 5.0 ) cfg2["fansclub_manual_wait_seconds"] = float( fansclub_manual_wait_var.get() or 3.0 ) cfg2["skip_if_countdown_lt_seconds"] = int(skip_lt_seconds_var.get() or 10) # 调试图像清理配置 if "debug_captures" not in cfg2 or not isinstance(cfg2["debug_captures"], dict): cfg2["debug_captures"] = {} cfg2["debug_captures"]["enabled"] = bool(debug_captures_enabled_var.get()) cfg2["debug_captures"]["auto_cleanup"] = bool( debug_captures_auto_cleanup_var.get() ) cfg2["debug_captures"]["keep_days"] = int( debug_captures_keep_days_var.get() or 7 ) cfg2["debug_captures"]["max_files"] = int( debug_captures_max_files_var.get() or 2000 ) cfg2["debug_captures"]["async_save"] = bool(debug_captures_async_save_var.get()) cfg2["debug_captures"]["log_on_complete"] = bool( debug_captures_log_on_complete_var.get() ) # 日志配置 if "logging" not in cfg2 or not isinstance(cfg2["logging"], dict): cfg2["logging"] = {} cfg2["logging"]["beautify_output"] = bool(logging_beautify_var.get()) cfg2["logging"]["color_output"] = bool(logging_color_var.get()) cfg2["logging"]["show_timestamps"] = bool(logging_show_timestamps_var.get()) cfg2["logging"]["debug_detail_level"] = str( logging_debug_level_var.get() or "normal" ) cfg2["logging"]["error_detail_level"] = str( logging_error_level_var.get() or "full" ) cfg2["logging"]["action_log_format"] = str( logging_action_format_var.get() or "concise" ) # 性能追踪配置 if "performance_tracking" not in cfg2["logging"] or not isinstance( cfg2["logging"]["performance_tracking"], dict ): cfg2["logging"]["performance_tracking"] = {} cfg2["logging"]["performance_tracking"]["enabled"] = bool( logging_performance_enabled_var.get() ) cfg2["logging"]["performance_tracking"]["track_function_calls"] = bool( logging_track_functions_var.get() ) cfg2["yanghao_enabled"] = bool(yg_enabled_var.get()) cfg2["yanghao_enable_actions"] = bool(yg_actions_enabled_var.get()) cfg2["yanghao_only"] = bool(yg_only_var.get()) cfg2["yanghao_recommend_duration_seconds"] = int( yg_recommend_duration_var.get() or 60 ) cfg2["yanghao_recommend_interval_seconds"] = int( yg_recommend_interval_var.get() or 0 ) cfg2["yanghao_like_prob"] = float(yg_like_prob_var.get() or 0.0) cfg2["yanghao_fav_prob"] = float(yg_fav_prob_var.get() or 0.0) cfg2["yanghao_comment_prob"] = float(yg_comment_prob_var.get() or 0.0) cfg2["yanghao_icon_roi_size"] = int(yg_icon_roi_size_var.get() or 240) cfg2["yanghao_icon_match_threshold"] = float( yg_icon_match_threshold_var.get() or 0.72 ) cfg2["yanghao_step_screenshot"] = bool(yg_step_screenshot_var.get()) cfg2["yanghao_like_roi_offset_x"] = int(yg_like_roi_offset_x_var.get() or 0) cfg2["yanghao_like_roi_offset_y"] = int(yg_like_roi_offset_y_var.get() or 0) cfg2["yanghao_fav_roi_offset_x"] = int(yg_fav_roi_offset_x_var.get() or 0) cfg2["yanghao_fav_roi_offset_y"] = int(yg_fav_roi_offset_y_var.get() or 0) cfg2["yanghao_like_icon_x"] = int(yg_like_icon_x_var.get() or 0) cfg2["yanghao_like_icon_y"] = int(yg_like_icon_y_var.get() or 0) cfg2["yanghao_fav_icon_x"] = int(yg_fav_icon_x_var.get() or 0) cfg2["yanghao_fav_icon_y"] = int(yg_fav_icon_y_var.get() or 0) cfg2["yanghao_like_template_path"] = str( yg_like_template_path_var.get() or "assets/like.png" ) cfg2["yanghao_fav_template_path"] = str( yg_fav_template_path_var.get() or "assets/fav.png" ) cfg2["yanghao_after_dwell_swipe_direction"] = str( yg_after_dwell_direction_var.get() or "up" ) cfg2["yanghao_after_dwell_swipe_distance_px"] = int( yg_after_dwell_distance_var.get() or 900 ) cfg2["yanghao_comment_btn_x"] = int(yg_comment_btn_x_var.get() or 0) cfg2["yanghao_comment_btn_y"] = int(yg_comment_btn_y_var.get() or 0) cfg2["yanghao_comment_input_x"] = int(yg_comment_input_x_var.get() or 0) cfg2["yanghao_comment_input_y"] = int(yg_comment_input_y_var.get() or 0) cfg2["yanghao_comment_send_x"] = int(yg_comment_send_x_var.get() or 0) cfg2["yanghao_comment_send_y"] = int(yg_comment_send_y_var.get() or 0) cfg2["yanghao_comment_close_x"] = int(yg_comment_close_x_var.get() or 0) cfg2["yanghao_comment_close_y"] = int(yg_comment_close_y_var.get() or 0) cfg2["yanghao_comment_texts"] = yg_comment_text_lines cfg2["yanghao_like_keywords"] = yg_like_kw_lines cfg2["yanghao_fav_keywords"] = yg_fav_kw_lines # 流式后台截图配置 cfg2["enable_streaming_screenshot"] = bool(streaming_enabled_var.get()) # GUI 配置 if "gui" not in cfg2 or not isinstance(cfg2["gui"], dict): cfg2["gui"] = {} cfg2["gui"]["theme"] = str(gui_theme_var.get() or "litera") write_config(cfg2) on_line("[配置] 已保存到 config.json") # 如果用户关闭了流式后台截图,尝试停止正在运行的服务实例以立即生效 try: from operations.screenshot_service import ScreenshotService if not bool(cfg2.get("enable_streaming_screenshot", True)): try: ScreenshotService.get_instance().stop() on_line("[截图服务] 已停止后台流式截图(配置更新)") except Exception: on_line("[截图服务] 停止后台截图服务失败(请重启程序以确保生效)") except Exception: # ignore if service module not available pass load_config_to_ui() # 顶部常驻按钮区域(与设备选择同一行,不随左侧滚动) top_btns = ttk.Frame(top) top_btns.pack(side=RIGHT, padx=(20, 0)) ttk.Button(top_btns, text="保存配置", command=save_ui_to_config).pack( side=LEFT, padx=(0, 8) ) # 截图+OCR 按钮也放在顶部,方便随时使用 # 具体回调在后文定义,这里先占位,通过 lambda 延迟绑定 screenshot_button_var = {"command": None} def _bind_screenshot_button(btn): # 在 do_screenshot 定义后调用,将真正的 command 绑定到按钮 screenshot_button_var["button"] = btn screenshot_btn = ttk.Button(top_btns, text="截图+OCR") screenshot_btn.pack(side=LEFT, padx=(0, 8)) _bind_screenshot_button(screenshot_btn) # OCR区域配置:定义所有需要识别的区域(坐标基于1080x2400基准) OCR_REGIONS = [ # (区域名称, (x1, y1, x2, y2), 描述) ("福袋内容", (389, 1273, 1000, 1534), "福袋内容详情"), ("福袋倒计时", (390, 1470, 980, 1580), "福袋倒计时"), ("福袋价值", (390, 1440, 1000, 1580), "奖品价值/价格"), ("抽奖结果", (380, 660, 720, 755), "抽奖结果弹窗"), ("推荐页标签栏", (400, 140, 900, 200), "推荐/关注/直播标签"), ("推荐页标签栏快速检测", (400, 140, 900, 200), "推荐页快速检测"), ("参与按钮", (306, 2030, 780, 2110), "参与福袋抽奖按钮"), ("无奖励确认", (340, 1195, 740, 1355), "无奖励确认弹窗"), ("奖励通知确认", (370, 1350, 680, 1440), "奖励通知确认"), ("订单确认", (370, 120, 700, 220), "订单确认页面"), ("关注列表标签", (658, 147, 765, 194), "关注列表标签"), ("直播列表标签", (400, 140, 900, 200), "直播列表标签"), ("直播广场", (400, 140, 900, 200), "直播广场标题"), ("直播间标题_中", (400, 140, 900, 200), "直播间标题中部"), ("诊断优惠券标题", (60, 1260, 1020, 1480), "优惠券弹窗标题"), ("诊断优惠券按钮", (400, 1600, 680, 1700), "优惠券按钮"), ("诊断购物红包", (400, 1400, 900, 1600), "购物红包弹窗"), ] # 截图按钮 def do_screenshot(): device_id = device_var.get().strip() if not device_id: on_line("[截图] 请先选择设备") return # 在后台线程中执行截图和OCR识别,避免阻塞GUI def screenshot_thread(): try: from Underlying_Operations import underlying_operations # 使用模块级别导入的 Image 与 os,避免重复导入导致 Pylance 警告 # 使用 root.after 在主线程中更新日志 def log_msg(msg: str) -> Callable[[], None]: def wrapper() -> None: on_line(msg) return wrapper root.after(0, log_msg("[截图] 正在截图...")) # type: ignore[arg-type] ops = underlying_operations() result = ops.get_screenshot(device_id, use_service=False) if not result: root.after(0, log_msg("[截图] 截图失败")) # type: ignore[arg-type] return root.after(0, log_msg("[截图] 截图成功,已保存到 pic/screenshot.png")) # type: ignore[arg-type] # 读取截图以获取实际尺寸 try: from path_config import get_screenshot_path screenshot_path = get_screenshot_path() except Exception: # 回退到旧路径(向后兼容) import path_config screenshot_path = path_config.get_screenshot_path() if not os.path.exists(screenshot_path): root.after(0, log_msg("[OCR] 截图文件不存在")) # type: ignore[arg-type] return try: img = Image.open(screenshot_path) img.load() # Force load to catch truncated files early img_width, img_height = img.size # 计算缩放比例(基于1080x2400基准) scale_x = img_width / 1080.0 scale_y = img_height / 2400.0 except (OSError, IOError, SyntaxError) as e: # Handle truncated image files root.after(0, log_msg(f"图片文件损坏或截断: {e}")) # type: ignore[arg-type] return except Exception as e: root.after(0, log_msg(f"[OCR] 读取截图失败: {e}")) # type: ignore[arg-type] return # 获取Y偏移 y_offset = int(y_var.get() or 0) # 执行所有OCR区域的识别 ocr_results = [] total_regions = len(OCR_REGIONS) root.after(0, log_msg(f"[OCR] 开始识别 {total_regions} 个区域...")) # type: ignore[arg-type] for idx, (region_name, (x1, y1, x2, y2), desc) in enumerate( OCR_REGIONS, 1 ): try: # 缩放坐标到实际截图尺寸 actual_x1 = int(x1 * scale_x) actual_y1 = int(y1 * scale_y) + y_offset actual_x2 = int(x2 * scale_x) actual_y2 = int(y2 * scale_y) + y_offset # 确保坐标在图片范围内 actual_x1 = max(0, min(actual_x1, img_width)) actual_y1 = max(0, min(actual_y1, img_height)) actual_x2 = max(0, min(actual_x2, img_width)) actual_y2 = max(0, min(actual_y2, img_height)) if actual_x1 >= actual_x2 or actual_y1 >= actual_y2: root.after(0, log_msg(f"[OCR] {region_name}: 坐标无效,跳过")) # type: ignore[arg-type] continue # 截取区域 cut_result = ops.cut_pic( (actual_x1, actual_y1), (actual_x2, actual_y2), "", region_name, ) if not cut_result: root.after(0, log_msg(f"[OCR] {region_name}: 截图失败")) # type: ignore[arg-type] ocr_results.append((region_name, desc, "", "截图失败")) continue # OCR识别(先尝试模式0,如果为空再尝试模式1) text_result = "" ocr_mode = 0 for mode in [0, 1]: try: text = str( ops.analyse_pic_word(region_name, mode) or "" ).strip() if text: text_result = text ocr_mode = mode break except Exception: continue ocr_results.append( (region_name, desc, text_result, f"模式{ocr_mode}") ) status_msg = f"[OCR] ({idx}/{total_regions}) {region_name}: {text_result[:50] if text_result else '(空)'}" root.after(0, log_msg(status_msg)) # type: ignore[arg-type] except Exception as e: error_msg = f"[OCR] {region_name}: 异常 - {e}" root.after(0, log_msg(error_msg)) # type: ignore[arg-type] ocr_results.append((region_name, desc, "", f"异常: {e}")) # 更新OCR结果标签页 def update_ocr_wrapper() -> None: update_ocr_results(ocr_results) root.after(0, update_ocr_wrapper) # type: ignore[arg-type] root.after(0, log_msg(f"[OCR] 完成!共识别 {len(ocr_results)} 个区域")) # type: ignore[arg-type] # 刷新截图预览(如果当前显示的是 screenshot.png) def refresh_if_screenshot() -> None: if image_var.get() == "screenshot.png": refresh_preview() root.after(0, refresh_if_screenshot) # type: ignore[arg-type] except Exception as e: import traceback error_detail = traceback.format_exc() root.after(0, log_msg(f"[截图] 截图异常: {e}\n{error_detail}")) # type: ignore[arg-type] thread = threading.Thread(target=screenshot_thread, daemon=True) thread.start() # 将顶部“截图+OCR”按钮的回调绑定到 do_screenshot try: btn = screenshot_button_var.get("button") if btn is not None: btn.configure(command=do_screenshot) except Exception: pass # 右侧:操作按钮区域(先创建,放在底部) actions = ttk.Frame(right) # 右侧:Notebook(日志 / 截图预览 / 统计信息 / 预约队列 / 高价值房间) notebook = ttk.Notebook(right) # 实时状态工具栏(固定在 Notebook 上方,始终可见) show_actions_var = tk.BooleanVar(value=True) show_screenshot_var = tk.BooleanVar(value=False) auto_scroll_var = tk.BooleanVar(value=True) realtime_tools = ttk.Frame(right) realtime_tools.pack(fill=X, padx=8, pady=(4, 0)) ttk.Checkbutton(realtime_tools, text="显示动作流", variable=show_actions_var).pack( side=LEFT, padx=(0, 8) ) ttk.Checkbutton(realtime_tools, text="显示截图", variable=show_screenshot_var).pack( side=LEFT, padx=(0, 8) ) ttk.Checkbutton(realtime_tools, text="自动滚动", variable=auto_scroll_var).pack( side=LEFT, padx=(0, 8) ) # forward-declare handler to satisfy linters; real function defined later open_realtime_viewer = lambda: None ttk.Button( realtime_tools, text="实时查看", width=10, command=lambda: open_realtime_viewer(), ).pack(side=LEFT, padx=(8, 0)) log_tab = ttk.Frame(notebook) preview_tab = ttk.Frame(notebook) stats_tab = ttk.Frame(notebook) reservation_tab = ttk.Frame(notebook) high_value_tab = ttk.Frame(notebook) actions_log_tab = ttk.Frame(notebook) realtime_tab = ttk.Frame(notebook) ocr_results_tab = ttk.Frame(notebook) win_record_tab = ttk.Frame(notebook) notebook.add(log_tab, text="运行日志") notebook.add(preview_tab, text="截图预览") notebook.add(stats_tab, text="统计信息") notebook.add(reservation_tab, text="预约队列") notebook.add(high_value_tab, text="高价值房间") notebook.add(actions_log_tab, text="行为日志") notebook.add(realtime_tab, text="实时状态") notebook.add(ocr_results_tab, text="OCR结果") notebook.add(win_record_tab, text="中奖记录") # 日志区 log_box = ttk.Frame(log_tab) log_box.pack(fill=BOTH, expand=True) # ========== 实时状态 Tab(显示最近动作 + 耗时) ========== try: realtime_frame = ttk.Frame(realtime_tab) realtime_frame.pack(fill=BOTH, expand=True, padx=8, pady=8) # 截图预览区域(根据选项显示/隐藏) image_label = ttk.Label(realtime_frame) image_label.pack(fill=X) realtime_text = ScrolledText(realtime_frame, height=14) realtime_text.pack(fill=BOTH, expand=True) realtime_text.configure(state="disabled") # re 已在模块顶部导入,避免重复导入 realtime_after_id = None def tail_read_file(path: str, max_bytes: int = 64 * 1024) -> list[str]: """从文件尾部读取最多 max_bytes,并返回按行分割的字符串列表(按文件顺序)。""" try: if not os.path.exists(path): return [] with open(path, "rb") as f: f.seek(0, os.SEEK_END) file_size = f.tell() seek_from = max(0, file_size - max_bytes) f.seek(seek_from) data = f.read() text = data.decode(errors="ignore") # splitlines 保留不含尾部换行的处理 return text.splitlines() except Exception: return [] def parse_action_duration(line: str) -> tuple[str, str] | None: """从一行日志提取 (action, duration),未找到返回 None。""" if "耗时" not in line: return None # 尝试提取耗时数字 m = re.search(r"耗时[:=]?\s*([0-9]+(?:\.[0-9]+)?)\s*s", line) dur = None if m: dur = m.group(1) + "s" else: m2 = re.search(r"([0-9]+(?:\.[0-9]+)?)\s*s", line) if m2: dur = m2.group(1) + "s" if not dur: return None # 动作名取耗时之前的文本片段,最多保留 60 字符 idx = line.find("耗时") action = line[:idx].strip() if not action: # 兜底:取整行前 60 字符 action = line.strip()[:60] if len(action) > 60: action = action[:57] + "..." return (action, dur) def refresh_realtime_tab(): nonlocal realtime_after_id cfg = read_config() gui_cfg = cfg.get("gui", {}).get("realtime_status", {}) refresh_ms = int(gui_cfg.get("refresh_interval_ms", 1000)) tail_items = int(gui_cfg.get("tail_items", 50)) path = os.path.join(get_logs_dir(), "actions.log") lines = tail_read_file(path) parsed: list[tuple[str, str]] = [] # 从文件末尾向前解析,保持原始顺序输出最近项 for line in reversed(lines): try: out = parse_action_duration(line) if out: parsed.append(out) if len(parsed) >= tail_items: break except Exception: continue parsed = list(reversed(parsed)) # 更新截图(若选中) if show_screenshot_var.get(): try: try: from path_config import get_screenshot_path screenshot_path = get_screenshot_path() except Exception: import path_config screenshot_path = path_config.get_screenshot_path() if os.path.exists(screenshot_path): img = Image.open(screenshot_path) # 缩放以适应宽度(保持纵横比),最大宽度 420 max_w = 420 w, h = img.size if w > max_w: nw = max_w nh = int(h * (nw / w)) img = img.resize((nw, nh), Image.LANCZOS) tk_img = ImageTk.PhotoImage(img) image_label.configure(image=tk_img) image_label.image = tk_img image_label.pack(fill=X) else: image_label.configure(image="") image_label.image = None image_label.pack_forget() except Exception: image_label.configure(image="") image_label.image = None image_label.pack_forget() else: image_label.configure(image="") image_label.image = None image_label.pack_forget() # 更新动作流文本(若选中) if show_actions_var.get(): realtime_text.configure(state="normal") realtime_text.delete("1.0", "end") if not parsed: realtime_text.insert("1.0", "暂无动作日志(仅显示包含“耗时”的行)") else: for action, dur in parsed: realtime_text.insert("end", f"{action} {dur}\n") # 自动滚动 if auto_scroll_var.get(): try: realtime_text.see("end") except Exception: try: realtime_text.yview_moveto(1.0) except Exception: pass realtime_text.configure(state="disabled") else: # 隐藏文本内容但保留控件 realtime_text.configure(state="normal") realtime_text.delete("1.0", "end") realtime_text.configure(state="disabled") # 安排下一次刷新 try: realtime_after_id = root.after(refresh_ms, refresh_realtime_tab) except Exception: realtime_after_id = None # 启动刷新(仅在 Tab 被创建时启动) try: refresh_realtime_tab() except Exception: pass except Exception: pass # --------- 实时查看弹窗(紧凑视图) --------- def open_realtime_viewer(): try: # 如果已打开则直接聚焦 if hasattr(open_realtime_viewer, "_win") and open_realtime_viewer._win: try: open_realtime_viewer._win.lift() except Exception: pass return win = tk.Toplevel(root) win.title("实时查看 - 截图与最简动作流") win.geometry("520x520") open_realtime_viewer._win = win # 图片与列表 img_lbl = ttk.Label(win) img_lbl.pack(fill=X, pady=(6, 4)) list_frame = ttk.Frame(win) list_frame.pack(fill=BOTH, expand=True, padx=6, pady=6) listbox = tk.Listbox(list_frame, height=12) listbox.pack(side=LEFT, fill=BOTH, expand=True) scrollbar = ttk.Scrollbar( list_frame, orient=tk.VERTICAL, command=listbox.yview ) scrollbar.pack(side=RIGHT, fill=Y) listbox.configure(yscrollcommand=scrollbar.set) stop_flag = {"stop": False} def close_win(): stop_flag["stop"] = True try: win.destroy() except Exception: pass open_realtime_viewer._win = None win.protocol("WM_DELETE_WINDOW", close_win) # use module-level `re` def tail_read(path: str, max_bytes: int = 64 * 1024) -> list[str]: try: if not os.path.exists(path): return [] with open(path, "rb") as f: f.seek(0, os.SEEK_END) sz = f.tell() f.seek(max(0, sz - max_bytes)) return f.read().decode(errors="ignore").splitlines() except Exception: return [] def parse_minimal(line: str) -> tuple[str, str] | None: if "耗时" not in line: return None m = re.search(r"耗时[:=]?\s*([0-9]+(?:\.[0-9]+)?)\s*s", line) dur = None if m: dur = m.group(1) + "s" else: m2 = re.search(r"([0-9]+(?:\.[0-9]+)?)\s*s", line) if m2: dur = m2.group(1) + "s" if not dur: return None idx = line.find("耗时") action = line[:idx].strip() if not action: action = line.strip()[:80] if len(action) > 80: action = action[:77] + "..." return (action, dur) def update_loop(): if stop_flag["stop"]: return # update image try: try: from path_config import get_screenshot_path screenshot_path = get_screenshot_path() except Exception: import path_config screenshot_path = path_config.get_screenshot_path() if os.path.exists(screenshot_path): img = Image.open(screenshot_path) max_w = 480 w, h = img.size if w > max_w: nw = max_w nh = int(h * (nw / w)) img = img.resize((nw, nh), Image.LANCZOS) tkimg = ImageTk.PhotoImage(img) img_lbl.configure(image=tkimg) img_lbl.image = tkimg else: img_lbl.configure(image=None) img_lbl.image = None except Exception: img_lbl.configure(image=None) img_lbl.image = None # update minimal list try: path = os.path.join(get_logs_dir(), "actions.log") lines = tail_read(path, max_bytes=64 * 1024) items: list[str] = [] for line in reversed(lines): out = parse_minimal(line) if out: items.append(f"{out[0]} {out[1]}") if len(items) >= 80: break items = list(reversed(items)) listbox.delete(0, tk.END) if not items: listbox.insert(tk.END, "暂无动作(仅显示包含 耗时 的行)") else: for it in items: listbox.insert(tk.END, it) # 自动滚动到末尾 try: listbox.yview_moveto(1.0) except Exception: pass except Exception: try: listbox.delete(0, tk.END) listbox.insert(tk.END, "更新失败") except Exception: pass # schedule next try: win.after(1000, update_loop) except Exception: return # start update_loop() except Exception: return # 搜索工具栏 log_search_frame = ttk.Frame(log_box) log_search_frame.pack(fill=X, padx=10, pady=(10, 5)) log_search_var = tk.StringVar(value="") log_search_entry = ttk.Entry( log_search_frame, textvariable=log_search_var, width=20 ) log_search_entry.pack(side=LEFT, padx=(0, 5)) log_search_matches = [] # 存储所有匹配的位置 log_current_match_index = -1 # 当前匹配的索引 def search_in_log_text(direction=1): """在运行日志中搜索文本""" nonlocal log_search_matches, log_current_match_index search_text = log_search_var.get().strip() if not search_text: # 清除高亮 log_text.tag_remove("search_highlight", "1.0", "end") log_search_matches = [] log_current_match_index = -1 return # 获取所有文本 content = log_text.get("1.0", "end-1c") if not content: return # 清除之前的高亮 log_text.tag_remove("search_highlight", "1.0", "end") log_text.tag_remove("search_current", "1.0", "end") # 配置高亮样式 log_text.tag_config("search_highlight", background="yellow") log_text.tag_config("search_current", background="orange") # 查找所有匹配项(不区分大小写) log_search_matches = [] start_pos = 0 # 使用整数索引 search_text_lower = search_text.lower() content_lower = content.lower() while True: # 在内容中查找 pos = content_lower.find(search_text_lower, start_pos) if pos == -1: break # 计算行号和列号 line_start = content[:pos].rfind("\n") + 1 line_num = content[:pos].count("\n") + 1 col_num = pos - line_start # 转换为 tkinter 索引格式 start_index = f"{line_num}.{col_num}" end_index = f"{line_num}.{col_num + len(search_text)}" log_search_matches.append((start_index, end_index)) start_pos = pos + 1 if not log_search_matches: # 没有找到匹配项 log_current_match_index = -1 return # 高亮所有匹配项 for start_idx, end_idx in log_search_matches: log_text.tag_add("search_highlight", start_idx, end_idx) # 根据方向更新当前匹配索引 if direction == 1: # 下一个 log_current_match_index = (log_current_match_index + 1) % len( log_search_matches ) else: # 上一个 log_current_match_index = (log_current_match_index - 1) % len( log_search_matches ) # 高亮当前匹配项并滚动到该位置 if log_current_match_index >= 0: start_idx, end_idx = log_search_matches[log_current_match_index] log_text.tag_add("search_current", start_idx, end_idx) log_text.see(start_idx) log_text.mark_set("insert", start_idx) def search_next_in_log(): """搜索下一个""" search_in_log_text(1) def search_prev_in_log(): """搜索上一个""" search_in_log_text(-1) def clear_search_in_log(): """清除搜索高亮""" nonlocal log_search_matches, log_current_match_index log_search_var.set("") log_text.tag_remove("search_highlight", "1.0", "end") log_text.tag_remove("search_current", "1.0", "end") log_search_matches = [] log_current_match_index = -1 # 绑定回车键搜索 def on_log_search_entry_key(event): if event.keysym == "Return": search_next_in_log() log_search_entry.bind("", on_log_search_entry_key) ttk.Button(log_search_frame, text="搜索", command=search_next_in_log).pack( side=LEFT, padx=(0, 2) ) ttk.Button(log_search_frame, text="上一个", command=search_prev_in_log).pack( side=LEFT, padx=(0, 2) ) ttk.Button(log_search_frame, text="下一个", command=search_next_in_log).pack( side=LEFT, padx=(0, 2) ) ttk.Button(log_search_frame, text="清除", command=clear_search_in_log).pack( side=LEFT, padx=(0, 5) ) log_text = ScrolledText(log_box) try: log_text.configure(font=("Consolas", 10)) except Exception: pass log_text.pack(fill=BOTH, expand=True, padx=10, pady=(0, 10)) # 配置日志颜色标签(如果支持颜色) try: # 根据主题调整日志颜色(明亮主题使用深色文字/蓝色系) light_themes = {"litera", "flatly", "journal", "minty", "cosmo"} try: current_theme = str(gui_theme_var.get() or "litera") except Exception: current_theme = "litera" if current_theme in light_themes: # 明亮主题 - 使用更适合人眼观看的颜色组合 log_text.configure( background="#FFFFFF", foreground="#2C2C2C", insertbackground="#2C2C2C" ) log_text.tag_configure("log_timestamp", foreground="#8B8B8B") # 柔和的灰色 log_text.tag_configure( "log_info", foreground="#1E88E5" ) # 明亮的蓝色,易于阅读 log_text.tag_configure( "log_warning", foreground="#F57C00" ) # 橙色,警告色但不过于刺眼 log_text.tag_configure( "log_error", foreground="#D32F2F" ) # 深红色,醒目但不刺眼 log_text.tag_configure( "log_critical", foreground="#B71C1C", font=("Consolas", 10, "bold") ) # 加粗深红色 log_text.tag_configure( "log_performance", foreground="#388E3C" ) # 深绿色,性能指标 log_text.tag_configure("log_module", foreground="#7B1FA2") # 紫色,模块标识 else: # 暗色主题 - 优化对比度和可读性 log_text.configure( background="#1E1E1E", foreground="#E0E0E0", insertbackground="#FFFFFF" ) log_text.tag_configure( "log_timestamp", foreground="#A0A0A0" ) # 浅灰色时间戳 log_text.tag_configure("log_info", foreground="#64B5F6") # 亮蓝色,信息级 log_text.tag_configure( "log_warning", foreground="#FFB74D" ) # 金色警告,暗色背景下醒目 log_text.tag_configure( "log_error", foreground="#EF5350" ) # 亮红色,错误突出 log_text.tag_configure( "log_critical", foreground="#F44336", font=("Consolas", 10, "bold") ) # 加粗亮红色 log_text.tag_configure( "log_performance", foreground="#81C784" ) # 亮绿色,性能数据 log_text.tag_configure( "log_module", foreground="#BA68C8" ) # 亮紫色,模块标识 # 配置操作类型颜色标签(使用模块化配置) try: color_config = get_color_config(current_theme) for op_type, colors in color_config.items(): tag_name = f"op_{op_type}" log_text.tag_configure( tag_name, foreground=colors["foreground"], background=colors["background"], ) except Exception: pass # 忽略操作类型颜色配置失败 except Exception: pass # 忽略标签配置失败 # 截图预览 preview_top = ttk.Frame(preview_tab) preview_top.pack(fill=X, padx=10, pady=10) try: from path_config import get_pic_dir images_dir = get_pic_dir() except Exception: # 回退到旧路径(向后兼容) import path_config images_dir = path_config.get_pic_dir() def scan_image_files(): """扫描pic文件夹及其子文件夹中的所有图片文件""" image_files = [] if os.path.exists(images_dir): for root, dirs, files in os.walk(images_dir): for file in files: if file.lower().endswith( (".png", ".jpg", ".jpeg", ".bmp", ".webp", ".gif") ): # 获取相对路径 rel_path = os.path.relpath(os.path.join(root, file), images_dir) # 统一使用正斜杠(Windows和Unix都支持) rel_path = rel_path.replace("\\", "/") image_files.append(rel_path) # 按文件名排序 image_files.sort(key=lambda x: x.lower()) return image_files image_var = tk.StringVar(value="") ttk.Label(preview_top, text="选择图片:").pack(side=LEFT) # 允许手工输入子路径(例如 start/latest.png),方便查看逐步截图 image_combo = ttk.Combobox( preview_top, textvariable=image_var, width=30, state="normal" ) image_combo.pack(side=LEFT, padx=(0, 10)) def update_image_list(refresh_after=True): """更新图片列表""" new_list = scan_image_files() image_combo["values"] = new_list current_value = image_var.get() # 如果当前值不在新列表中,或列表为空,选择第一个 if new_list: if not current_value or current_value not in new_list: image_var.set(new_list[0]) else: image_var.set("") on_line(f"[预览] 扫描到 {len(new_list)} 个图片文件") # 如果当前有选择的图片,刷新预览(如果refresh_after为True且refresh_preview已定义) if refresh_after and image_var.get(): try: refresh_preview() except NameError: # refresh_preview还没定义,忽略 pass # 先定义refresh_preview函数(即使它引用了后面的变量,函数定义本身是延迟执行的) def refresh_preview(): name = image_var.get().strip() if not name: preview_status.set("请选择图片") image_label.configure(image="") _img_ref["photo"] = None return # 处理相对路径(将正斜杠转换为系统路径分隔符) name_normalized = name.replace("/", os.sep) path = os.path.join(images_dir, name_normalized) _load_and_fit_image(path) update_image_list(refresh_after=False) # 初始化时扫描一次,但不刷新预览 preview_status = tk.StringVar(value="") ttk.Label(preview_top, textvariable=preview_status).pack(side=RIGHT) preview_body = ttk.Frame(preview_tab) preview_body.pack(fill=BOTH, expand=True, padx=10, pady=(0, 10)) image_label = ttk.Label(preview_body) image_label.pack(fill=BOTH, expand=True) _img_ref: dict[str, Any] = {"photo": None} # 防止 PhotoImage 被回收 def _load_and_fit_image(img_path: str) -> None: if not os.path.exists(img_path): preview_status.set(f"未找到:{os.path.basename(img_path)}") image_label.configure(image="") _img_ref["photo"] = None return try: img = Image.open(img_path) img.load() # Force load to catch truncated files early img = img.convert("RGB") except (OSError, IOError, SyntaxError) as e: # Handle truncated image files preview_status.set(f"图片加载失败:{str(e)[:50]}") image_label.configure(image="") _img_ref["photo"] = None return except Exception as e: preview_status.set(f"图片加载错误:{str(e)[:50]}") image_label.configure(image="") _img_ref["photo"] = None return # 获取预览区域的实际尺寸(如果窗口还未初始化,使用默认值) try: preview_body.update_idletasks() # 强制更新布局 w = preview_body.winfo_width() h = preview_body.winfo_height() # 如果尺寸无效(窗口未初始化),使用默认值 if w <= 1 or h <= 1: w, h = 900, 520 except Exception: w, h = 900, 520 max_w = max(300, w - 20) max_h = max(200, h - 20) try: resample = Image.Resampling.LANCZOS except AttributeError: # Fallback for older Pillow versions: LANCZOS constant value is 1 resample = 1 # type: ignore[assignment] img.thumbnail((max_w, max_h), resample) photo: ImageTk.PhotoImage = ImageTk.PhotoImage(img) _img_ref["photo"] = photo # type: ignore[assignment] image_label.configure(image=photo) preview_status.set(f"{os.path.basename(img_path)} {img.width}x{img.height}") ttk.Button( preview_top, text="刷新列表", command=lambda: update_image_list(refresh_after=True), ).pack(side=LEFT, padx=(0, 5)) ttk.Button(preview_top, text="刷新预览", command=refresh_preview).pack(side=LEFT) # 绑定选择变化事件,自动刷新预览(在 refresh_preview 函数定义之后) def on_image_selected(*args): """当用户选择图片时自动刷新预览""" try: refresh_preview() except Exception: pass # 忽略错误,避免影响其他功能 image_var.trace("w", on_image_selected) # 监听变量变化 image_combo.bind( "<>", lambda e: refresh_preview() ) # 监听下拉选择 def open_pic_folder(): try: os.makedirs(images_dir, exist_ok=True) os.startfile(images_dir) # type: ignore[attr-defined] except Exception as e: on_line(f"[预览] 打开图片目录失败:{e}") ttk.Button(preview_top, text="打开pic目录", command=open_pic_folder).pack( side=LEFT, padx=(10, 0) ) status_var = tk.StringVar(value="就绪") def get_params() -> RunParams: # 如果启用无限循环,设置 wait_minutes=0 wait_minutes_value = ( 0 if infinite_loop_var.get() else int(wait_minutes_var.get() or 5) ) return RunParams( device_id=device_var.get().strip(), y_pianyi=int(y_var.get()), needswitch=bool(needswitch_var.get()), wait_minutes=wait_minutes_value, skip_if_countdown_gt_seconds=int(skip_gt_seconds_var.get() or 900), reset_after_swipes_enabled=bool(reset_after_swipes_enabled_var.get()), reset_after_swipes=int(reset_after_swipes_var.get() or 10), min_prize_value_yuan=float(min_value_var.get() or 0), min_participants=int(min_participants_var.get() or 0), max_participants=int(max_participants_var.get() or 0), auto_join_fansclub=bool(auto_join_var.get()), fansclub_fail_action=str(fansclub_action_var.get() or "stay").lower(), # Web端新增参数 high_value_room_revisit_enabled=bool( high_value_room_revisit_enabled_var.get() ), high_value_room_revisit_only_current_run=bool( high_value_room_revisit_only_current_run_var.get() ), reservation_back_verify_enabled=bool( reservation_back_verify_enabled_var.get() ), reservation_back_swipe_delay=float( reservation_back_swipe_delay_var.get() or 1.0 ), reservation_preempt_min_value=float( reservation_preempt_min_value_var.get() or 1000 ), fudai_find_max_attempts=int(fudai_find_max_attempts_var.get() or 5), enable_ocr_mode1=bool(enable_ocr_mode1_var.get()), fudai_template_match_enabled=bool(fudai_template_match_enabled_var.get()), fudai_template_match_threshold=float( fudai_template_match_threshold_var.get() or 0.7 ), # 只养号模式与养号时长 yanghao_only=bool(yg_only_var.get()), yanghao_seconds=int(yg_recommend_duration_var.get() or 0), ) def start_run(): if runner.is_running(): on_line("[运行] 已在运行中") return save_ui_to_config() params = get_params() wait_display = "∞" if params.wait_minutes == 0 else f"{params.wait_minutes}m" on_line( f"[运行] 启动:device={params.device_id or '(auto)'} y={params.y_pianyi} " f"needswitch={params.needswitch} wait={wait_display} " f"skip_gt={params.skip_if_countdown_gt_seconds}s reset_after_enabled={params.reset_after_swipes_enabled} reset_after={params.reset_after_swipes} " f"value>={params.min_prize_value_yuan} participants=[{params.min_participants},{params.max_participants}] " f"high_value_revisit={params.high_value_room_revisit_enabled} reservation_verify={params.reservation_back_verify_enabled} " f"fudai_find_max={params.fudai_find_max_attempts} yanghao=recommend_flow_only" ) status_var.set("运行中") try: runner.start(params) except Exception as e: status_var.set("启动失败") on_line(f"[错误] {e}") def stop_run(): runner.stop() status_var.set("已停止") # 先打包 actions 到底部(不 expand,固定在底部) actions.pack(fill=X, pady=(10, 0), padx=12, side="bottom") # 然后打包 notebook 填充剩余空间(在 actions 之上) notebook.pack(fill=BOTH, expand=True) ttk.Button(actions, text="开始运行", command=start_run).pack(side=LEFT, padx=(0, 8)) ttk.Button(actions, text="停止", command=stop_run).pack(side=LEFT, padx=(0, 4)) def force_stop_run(): """强制终止后台进程(包括可能残留的子进程)。""" runner.force_stop() status_var.set("已停止(强制)") ttk.Button(actions, text="强制停止", command=force_stop_run).pack( side=LEFT, padx=(0, 8) ) # (已移除:测试养号/测试评论 按钮与相关UI) def send_back_key(): dev = device_var.get().strip() try: runner.send_back_key(dev) except Exception as e: on_line(f"[错误] 发送返回键失败: {e}") ttk.Button(actions, text="发送返回键", command=send_back_key).pack( side=LEFT, padx=(0, 8) ) ttk.Label(actions, textvariable=status_var).pack(side=RIGHT) def pump_logs(): changed = False try: # 获取当前主题(用于颜色配置) try: current_theme = str(gui_theme_var.get() or "litera") except Exception: current_theme = "litera" while True: line = q.get_nowait() try: # 插入日志行并应用颜色标签 start_pos = log_text.index("end-1c") # 插入文本 log_text.insert("end", line + "\n") end_pos = log_text.index("end-1c") # 优先级1: 先检查操作类型颜色(更具体) op_type_applied = False try: op_type = get_operation_type(line) if op_type: apply_operation_color( log_text, start_pos, end_pos, line, current_theme ) op_type_applied = True except Exception: pass # 忽略操作类型颜色应用失败 # 优先级2: 再检查日志级别标签(作为补充,如果操作类型未匹配) # 只有在没有操作类型颜色时才应用级别标签 if not op_type_applied: try: tag = None if "[INFO]" in line: tag = "log_info" elif "[WARNING]" in line: tag = "log_warning" elif "[ERROR]" in line: tag = "log_error" elif "[CRITICAL]" in line: tag = "log_critical" elif "elapsed_seconds=" in line or "耗时" in line: tag = "log_performance" elif re.search(r"\[[\w\.]+\]", line): tag = "log_module" if tag: log_text.tag_add(tag, start_pos, end_pos) except Exception: pass # 忽略级别标签应用失败 # 不再自动滚动到底部,让用户自由控制滚动位置 changed = True except Exception as e: # 如果插入日志失败,至少打印到控制台(调试用) print(f"[GUI日志错误] 无法插入日志: {e}", file=sys.stderr) except queue.Empty: pass except Exception as e: # 捕获其他异常,确保日志循环不会中断 print(f"[GUI日志错误] pump_logs异常: {e}", file=sys.stderr) try: if changed and not runner.is_running() and status_var.get() == "运行中": status_var.set("已结束") except Exception: pass # 确保递归调用始终执行,即使前面出现异常 try: root.after(100, pump_logs) # type: ignore[arg-type] except Exception as e: # 如果 root 已被销毁,停止日志循环 print(f"[GUI日志错误] 无法调度下次日志更新: {e}", file=sys.stderr) # 统计信息显示 stats_top = ttk.Frame(stats_tab) stats_top.pack(fill=X, padx=10, pady=(10, 0)) stats_text = ScrolledText(stats_tab) stats_text.pack(fill=BOTH, expand=True, padx=10, pady=10) try: stats_text.configure(font=("Consolas", 10)) except Exception: pass def refresh_stats(): try: stats = runner.get_stats() lines = [] # 基本信息 lines.append("=" * 60) lines.append("运行状态信息") lines.append("=" * 60) lines.append(f"运行状态: {'运行中' if stats.get('running') else '未运行'}") lines.append(f"PID: {stats.get('pid') or '-'}") uptime_seconds = stats.get("uptime_seconds", 0) if uptime_seconds > 0: hours = uptime_seconds // 3600 minutes = (uptime_seconds % 3600) // 60 seconds = uptime_seconds % 60 lines.append(f"运行时长: {hours:02d}:{minutes:02d}:{seconds:02d}") else: lines.append(f"运行时长: -") last_log_ts = stats.get("last_log_ts") if last_log_ts: dt = datetime.fromtimestamp(last_log_ts) lines.append("最近日志时间: " + dt.strftime("%Y-%m-%d %H:%M:%S")) else: lines.append("最近日志时间: -") exit_code = stats.get("exit_code") lines.append(f"退出码: {exit_code if exit_code is not None else '-'}") lines.append("") # 计数器统计 counters = stats.get("counters", {}) # 快速汇总(关键指标) fudai_seen = counters.get("fudai_seen", 0) fudai_attend_ok = counters.get("fudai_attend_ok", 0) fudai_result_win = counters.get("fudai_result_win", 0) fudai_order_success = counters.get("fudai_order_success", 0) if fudai_seen > 0 or fudai_attend_ok > 0 or fudai_result_win > 0: lines.append("=" * 60) lines.append("快速汇总") lines.append("=" * 60) lines.append(f"识别福袋: {fudai_seen} 个") lines.append(f"参与成功: {fudai_attend_ok} 次") lines.append(f"中奖次数: {fudai_result_win} 次") lines.append(f"下单成功: {fudai_order_success} 次") if uptime_seconds > 0: hours = uptime_seconds / 3600.0 if hours > 0: lines.append( f"运行效率: {fudai_attend_ok / hours:.1f} 次参与/小时" ) lines.append("") # 核心统计(总是显示,即使数据为0) lines.append("=" * 60) lines.append("核心统计") lines.append("=" * 60) # 福袋相关核心指标(重新获取,避免重复定义) fudai_open_detail = counters.get("fudai_open_detail", 0) fudai_click_attend = counters.get("fudai_click_attend", 0) fudai_attend_ok = counters.get("fudai_attend_ok", 0) fudai_attend_fail = counters.get("fudai_attend_fail", 0) fudai_result_win = counters.get("fudai_result_win", 0) fudai_result_no_win = counters.get("fudai_result_no_win", 0) fudai_order_success = counters.get("fudai_order_success", 0) lines.append(f"福袋识别次数: {fudai_seen}") lines.append(f"打开详情: {fudai_open_detail}") if fudai_seen > 0: open_rate = (fudai_open_detail / fudai_seen) * 100 lines.append(f" 打开成功率: {open_rate:.1f}%") lines.append(f"点击参与: {fudai_click_attend}") if fudai_open_detail > 0: click_rate = (fudai_click_attend / fudai_open_detail) * 100 lines.append(f" 点击率: {click_rate:.1f}%") lines.append(f"参与成功: {fudai_attend_ok}") lines.append(f"参与失败: {fudai_attend_fail}") # 参与成功率应该基于点击参与次数来计算 # 因为参与成功可能包括"检测到已参与"的情况(没有点击) if fudai_click_attend > 0: # 通过点击参与成功的次数(不超过点击参与次数) click_attend_success = min(fudai_attend_ok, fudai_click_attend) success_rate = (click_attend_success / fudai_click_attend) * 100 lines.append(f" 参与成功率: {success_rate:.1f}%") # 如果参与成功 > 点击参与,说明有检测到已参与的情况 if fudai_attend_ok > fudai_click_attend: detected_already_attended = fudai_attend_ok - fudai_click_attend lines.append( f" (其中 {detected_already_attended} 次为检测到已参与状态)" ) elif fudai_attend_ok > 0 or fudai_attend_fail > 0: # 如果没有点击参与但有参与结果,使用原来的计算方式 total_attend = fudai_attend_ok + fudai_attend_fail if total_attend > 0: success_rate = (fudai_attend_ok / total_attend) * 100 lines.append(f" 参与成功率: {success_rate:.1f}%") lines.append(f"中奖次数: {fudai_result_win}") lines.append(f"未中奖次数: {fudai_result_no_win}") total_results = fudai_result_win + fudai_result_no_win # 检查数据一致性:参与成功次数应该 >= 开奖结果次数 if fudai_attend_ok > 0 and total_results < fudai_attend_ok: pending_results = fudai_attend_ok - total_results lines.append( f" 注意: 有 {pending_results} 次参与成功尚未开奖(或开奖结果未识别)" ) if total_results > 0: win_rate = (fudai_result_win / total_results) * 100 lines.append(f" 中奖率: {win_rate:.1f}%") lines.append(f"下单成功: {fudai_order_success}") # 效率统计 if uptime_seconds > 0: hours = uptime_seconds / 3600.0 if hours > 0: lines.append("") lines.append("效率统计(每小时):") if fudai_seen > 0: lines.append(f" 识别福袋: {fudai_seen / hours:.1f} 个/小时") if fudai_attend_ok > 0: lines.append( f" 参与成功: {fudai_attend_ok / hours:.1f} 次/小时" ) if total_results > 0: lines.append(f" 开奖次数: {total_results / hours:.1f} 次/小时") if fudai_result_win > 0: lines.append( f" 中奖次数: {fudai_result_win / hours:.2f} 次/小时" ) lines.append("") # 跳过原因统计 skip_stats = [ ("fudai_skip_value_low", "跳过-价值过低"), ("fudai_skip_participants_low", "跳过-人数过少"), ("fudai_skip_participants_high", "跳过-人数过多"), ("fudai_skip_content", "跳过-内容不理想"), ("fudai_skip_countdown_short", "跳过-倒计时太短"), ("fudai_skip_countdown_long", "跳过-倒计时太长"), ("fudai_skip_watch_required", "跳过-需要看播"), ] # 高价值预约统计 fudai_reserved_high_value = counters.get("fudai_reserved_high_value", 0) if fudai_reserved_high_value > 0: lines.append("=" * 60) lines.append("高价值预约统计") lines.append("=" * 60) lines.append( f"倒计时大于阈值但价值达到高价值阈值,记录预约: {fudai_reserved_high_value}" ) lines.append("") # 等待开奖统计 fudai_waiting_lottery = counters.get("fudai_waiting_lottery", 0) if fudai_waiting_lottery > 0: lines.append("=" * 60) lines.append("等待开奖统计") lines.append("=" * 60) lines.append(f"等待开奖次数: {fudai_waiting_lottery}") lines.append("") # 阶段诊断统计 stage_diagnosis_complete = counters.get("stage_diagnosis_complete", 0) stage_diagnosis_failed = counters.get("stage_diagnosis_failed", 0) if stage_diagnosis_complete > 0 or stage_diagnosis_failed > 0: lines.append("=" * 60) lines.append("阶段诊断统计") lines.append("=" * 60) lines.append(f"诊断完成: {stage_diagnosis_complete}") lines.append(f"诊断失败: {stage_diagnosis_failed}") if stage_diagnosis_complete > 0: success_rate = ( stage_diagnosis_complete / (stage_diagnosis_complete + stage_diagnosis_failed) ) * 100 lines.append(f"成功率: {success_rate:.1f}%") lines.append("") # OCR识别统计 ocr_attempt = counters.get("ocr_attempt", 0) ocr_success = counters.get("ocr_success", 0) ocr_failed = counters.get("ocr_failed", 0) if ocr_attempt > 0: lines.append("=" * 60) lines.append("OCR识别统计") lines.append("=" * 60) lines.append(f"OCR尝试次数: {ocr_attempt}") lines.append(f"OCR成功次数: {ocr_success}") lines.append(f"OCR失败次数: {ocr_failed}") total_ocr_results = ocr_success + ocr_failed if total_ocr_results < ocr_attempt: lines.append( f" 注意: 有 {ocr_attempt - total_ocr_results} 次尝试未记录结果(可能日志格式不匹配)" ) if ocr_attempt > 0: ocr_rate = (ocr_success / ocr_attempt) * 100 lines.append(f"OCR成功率: {ocr_rate:.1f}%") lines.append("") # 详情识别统计 fudai_detail_read_attempt = counters.get("fudai_detail_read_attempt", 0) fudai_detail_read_success = counters.get("fudai_detail_read_success", 0) fudai_detail_read_failed = counters.get("fudai_detail_read_failed", 0) if fudai_detail_read_attempt > 0: lines.append("=" * 60) lines.append("详情识别统计") lines.append("=" * 60) lines.append(f"详情识别尝试: {fudai_detail_read_attempt}") lines.append(f"详情识别成功: {fudai_detail_read_success}") lines.append(f"详情识别失败: {fudai_detail_read_failed}") total_detail_results = ( fudai_detail_read_success + fudai_detail_read_failed ) if total_detail_results < fudai_detail_read_attempt: lines.append( f" 注意: 有 {fudai_detail_read_attempt - total_detail_results} 次尝试未记录结果(可能日志格式不匹配)" ) if fudai_detail_read_attempt > 0: detail_rate = ( fudai_detail_read_success / fudai_detail_read_attempt ) * 100 lines.append(f"详情识别成功率: {detail_rate:.1f}%") lines.append("") # 福袋查找统计 fudai_find_success = counters.get("fudai_find_success", 0) fudai_find_not_found = counters.get("fudai_find_not_found", 0) fudai_find_timeout = counters.get("fudai_find_timeout", 0) if ( fudai_find_success > 0 or fudai_find_not_found > 0 or fudai_find_timeout > 0 ): lines.append("=" * 60) lines.append("福袋查找统计") lines.append("=" * 60) lines.append(f"查找成功: {fudai_find_success}") lines.append(f"未找到: {fudai_find_not_found}") lines.append(f"等待超时: {fudai_find_timeout}") lines.append("") # 性能统计(慢操作) slow_operation = counters.get("slow_operation", 0) if slow_operation > 0: lines.append("=" * 60) lines.append("性能统计") lines.append("=" * 60) lines.append(f"慢操作(>5秒)次数: {slow_operation}") lines.append("") skip_total = sum(counters.get(key, 0) for key, _ in skip_stats) if skip_total > 0: lines.append("=" * 60) lines.append("跳过原因统计") lines.append("=" * 60) lines.append(f"总跳过次数: {skip_total}") if fudai_seen > 0: skip_rate = (skip_total / fudai_seen) * 100 lines.append(f"跳过率: {skip_rate:.1f}%") lines.append("") for key, label in skip_stats: val = counters.get(key, 0) if val > 0: percentage = (val / skip_total) * 100 if skip_total > 0 else 0 lines.append(f" {label}: {val} ({percentage:.1f}%)") lines.append("") # 粉丝团统计 fansclub_stats = [ ("fansclub_required", "需要粉丝团"), ("fansclub_manual_needed", "需手动加入"), ("fansclub_unresolved", "未解决"), ] fansclub_total = sum(counters.get(key, 0) for key, _ in fansclub_stats) if fansclub_total > 0: lines.append("=" * 60) lines.append("粉丝团相关统计") lines.append("=" * 60) for key, label in fansclub_stats: val = counters.get(key, 0) if val > 0: percentage = ( (val / fansclub_total) * 100 if fansclub_total > 0 else 0 ) lines.append(f" {label}: {val} ({percentage:.1f}%)") lines.append("") # 直播间切换统计 switch_val = counters.get("switch_room", 0) if switch_val > 0: lines.append("=" * 60) lines.append("直播间切换统计") lines.append("=" * 60) lines.append(f"总切换次数: {switch_val}") if uptime_seconds > 0: hours = uptime_seconds / 3600.0 if hours > 0: lines.append(f"切换频率: {switch_val / hours:.1f} 次/小时") lines.append("") switch_reasons = [ ("switch_room_no_fudai", "无福袋"), ("switch_room_participants", "人数不符合"), ("switch_room_value", "价值不符合"), ("switch_room_content", "内容不符合"), ("switch_room_countdown", "倒计时不符合"), ("switch_room_attend_fail", "参与失败"), ] for key, label in switch_reasons: val = counters.get(key, 0) if val > 0: percentage = (val / switch_val) * 100 if switch_val > 0 else 0 lines.append(f" {label}: {val} ({percentage:.1f}%)") lines.append("") # 预约相关统计(详细版) reservation_recorded = counters.get("reservation_recorded", 0) reservation_window_entered = counters.get("reservation_window_entered", 0) reservation_back_success = counters.get("reservation_back_success", 0) reservation_back_verify_ok = counters.get("reservation_back_verify_ok", 0) reservation_back_verify_fail = counters.get( "reservation_back_verify_fail", 0 ) reservation_window_not_reached = counters.get( "reservation_window_not_reached", 0 ) reservation_expired = counters.get("reservation_expired", 0) reservation_queue_empty = counters.get("reservation_queue_empty", 0) reservation_locked = counters.get("reservation_locked", 0) reservation_back_to_first = counters.get("reservation_back_to_first", 0) reservation_queue_full_wait = counters.get("reservation_queue_full_wait", 0) reservation_drop_low_value = counters.get("reservation_drop_low_value", 0) reservation_clear = counters.get("reservation_clear", 0) reservation_back_direct_attend = counters.get( "reservation_back_direct_attend", 0 ) reservation_queue_full_back_attend = counters.get( "reservation_queue_full_back_attend", 0 ) reservation_duplicate_detected = counters.get( "reservation_duplicate_detected", 0 ) reservation_back_operation = counters.get("reservation_back_operation", 0) reservation_total = ( reservation_recorded + reservation_window_entered + reservation_back_success + reservation_back_verify_ok + reservation_back_verify_fail + reservation_window_not_reached + reservation_expired + reservation_queue_empty + reservation_locked + reservation_back_to_first + reservation_queue_full_wait + reservation_drop_low_value + reservation_clear + reservation_back_direct_attend + reservation_queue_full_back_attend + reservation_duplicate_detected + reservation_back_operation ) if reservation_total > 0 or reservation_recorded > 0: lines.append("=" * 60) lines.append("预约相关统计(详细)") lines.append("=" * 60) # 预约记录统计 if reservation_recorded > 0: lines.append(f"记录预约总数: {reservation_recorded}") # 预约回退统计 if reservation_back_success > 0: lines.append(f"成功回退到预约直播间: {reservation_back_success}") # 回退校验统计 verify_total = reservation_back_verify_ok + reservation_back_verify_fail if verify_total > 0: verify_rate = (reservation_back_verify_ok / verify_total) * 100 lines.append( f"回退校验: {reservation_back_verify_ok} 成功 / {reservation_back_verify_fail} 失败 (成功率: {verify_rate:.1f}%)" ) # 预约窗口统计 if reservation_window_entered > 0: lines.append(f"进入预约参与窗口: {reservation_window_entered}") if reservation_window_not_reached > 0: lines.append( f"时间窗口未到(跳过): {reservation_window_not_reached}" ) # 预约状态统计 if reservation_expired > 0: lines.append(f"过期预约(已清理): {reservation_expired}") if reservation_locked > 0: lines.append(f"锁定期未结束(跳过): {reservation_locked}") if reservation_queue_empty > 0: lines.append(f"预约队列为空(检查次数): {reservation_queue_empty}") if reservation_queue_full_wait > 0: lines.append(f"队列已满等待: {reservation_queue_full_wait}") if reservation_back_to_first > 0: lines.append(f"回退到第一个直播间: {reservation_back_to_first}") # 预约管理统计 if reservation_drop_low_value > 0: lines.append(f"丢弃低价值预约: {reservation_drop_low_value}") if reservation_clear > 0: lines.append(f"清空预约队列: {reservation_clear}") if reservation_duplicate_detected > 0: lines.append(f"检测到重复预约: {reservation_duplicate_detected}") # 回退后直接参与统计 if reservation_back_direct_attend > 0: lines.append(f"回退后直接参与: {reservation_back_direct_attend}") if reservation_queue_full_back_attend > 0: lines.append( f"队列满回退后参与: {reservation_queue_full_back_attend}" ) if reservation_back_operation > 0: lines.append(f"回退操作次数: {reservation_back_operation}") # 预约成功率 if reservation_recorded > 0 and reservation_back_success > 0: back_rate = (reservation_back_success / reservation_recorded) * 100 lines.append( f"预约回退成功率: {back_rate:.1f}% ({reservation_back_success}/{reservation_recorded})" ) lines.append("") # 错误统计(详细版) error_total = counters.get("error_total", 0) error_unbound_local = counters.get("error_unbound_local", 0) error_attribute = counters.get("error_attribute", 0) error_key = counters.get("error_key", 0) error_value = counters.get("error_value", 0) error_type = counters.get("error_type", 0) error_timeout = counters.get("error_timeout", 0) error_connection = counters.get("error_connection", 0) error_ocr = counters.get("error_ocr", 0) error_screenshot = counters.get("error_screenshot", 0) error_detection = counters.get("error_detection", 0) error_stage_diagnosis = counters.get("error_stage_diagnosis", 0) error_read_detail = counters.get("error_read_detail", 0) error_config_load = counters.get("error_config_load", 0) error_state_file = counters.get("error_state_file", 0) error_live_room_detect = counters.get("error_live_room_detect", 0) error_fudai_find = counters.get("error_fudai_find", 0) fudai_open_error = counters.get("fudai_open_error", 0) fudai_open_error_too_many = counters.get("fudai_open_error_too_many", 0) error_all = ( error_total + error_unbound_local + error_attribute + error_key + error_value + error_type + error_timeout + error_connection + error_ocr + error_screenshot + error_detection + error_stage_diagnosis + error_read_detail + error_config_load + error_state_file + error_live_room_detect + error_fudai_find + fudai_open_error + fudai_open_error_too_many ) if error_all > 0: lines.append("=" * 60) lines.append("错误统计(详细)") lines.append("=" * 60) # 总错误数 if error_total > 0: lines.append(f"总错误数: {error_total}") # 福袋相关错误 fudai_errors = fudai_open_error + fudai_open_error_too_many if fudai_errors > 0: lines.append("") lines.append("福袋相关错误:") if fudai_open_error > 0: lines.append(f" 打开福袋异常: {fudai_open_error}") if fudai_open_error_too_many > 0: lines.append(f" 打开失败次数过多: {fudai_open_error_too_many}") # Python异常类型 python_errors = ( error_unbound_local + error_attribute + error_key + error_value + error_type ) if python_errors > 0: lines.append("") lines.append("Python异常类型:") if error_unbound_local > 0: lines.append(f" UnboundLocalError: {error_unbound_local}") if error_attribute > 0: lines.append(f" AttributeError: {error_attribute}") if error_key > 0: lines.append(f" KeyError: {error_key}") if error_value > 0: lines.append(f" ValueError: {error_value}") if error_type > 0: lines.append(f" TypeError: {error_type}") # 功能模块错误 module_errors = ( error_ocr + error_screenshot + error_detection + error_stage_diagnosis + error_read_detail + error_config_load + error_state_file + error_live_room_detect + error_fudai_find ) if module_errors > 0: lines.append("") lines.append("功能模块错误:") if error_ocr > 0: lines.append(f" OCR识别错误: {error_ocr}") if error_screenshot > 0: lines.append(f" 截图错误: {error_screenshot}") if error_detection > 0: lines.append(f" 识别错误: {error_detection}") if error_stage_diagnosis > 0: lines.append(f" 阶段诊断错误: {error_stage_diagnosis}") if error_read_detail > 0: lines.append(f" 读取详情错误: {error_read_detail}") if error_config_load > 0: lines.append(f" 配置加载错误: {error_config_load}") if error_state_file > 0: lines.append(f" 状态文件错误: {error_state_file}") if error_live_room_detect > 0: lines.append(f" 直播间检测错误: {error_live_room_detect}") if error_fudai_find > 0: lines.append(f" 福袋查找错误: {error_fudai_find}") # 网络和超时错误 network_errors = error_timeout + error_connection if network_errors > 0: lines.append("") lines.append("网络和超时错误:") if error_timeout > 0: lines.append(f" 超时错误: {error_timeout}") if error_connection > 0: lines.append(f" 连接错误: {error_connection}") # 错误率统计 if uptime_seconds > 0 and error_all > 0: hours = uptime_seconds / 3600.0 if hours > 0: lines.append("") lines.append(f"错误频率: {error_all / hours:.2f} 次/小时") lines.append("") # 价值统计(从事件中提取) events = stats.get("events", []) prize_values = [] for event in events: meta = event.get("meta", {}) if "prize_value_yuan" in meta and meta["prize_value_yuan"] is not None: try: prize_values.append(float(meta["prize_value_yuan"])) except (ValueError, TypeError): pass if prize_values: lines.append("=" * 60) lines.append("价值统计") lines.append("=" * 60) total_value = sum(prize_values) avg_value = total_value / len(prize_values) max_value = max(prize_values) min_value = min(prize_values) lines.append(f"识别到的福袋总数: {len(prize_values)}") # 说明:价值统计只统计了成功识别到价值的福袋,可能少于总识别次数 if fudai_seen > len(prize_values): lines.append( f" (总识别次数: {fudai_seen},其中 {len(prize_values)} 个成功识别到价值)" ) lines.append(f"总价值: {total_value:.2f} 元") lines.append(f"平均价值: {avg_value:.2f} 元") lines.append(f"最高价值: {max_value:.2f} 元") lines.append(f"最低价值: {min_value:.2f} 元") # 价值分布 high_value_count = sum(1 for v in prize_values if v >= 500) medium_value_count = sum(1 for v in prize_values if 100 <= v < 500) low_value_count = sum(1 for v in prize_values if v < 100) lines.append("") lines.append("价值分布:") lines.append( f" 高价值(≥500元): {high_value_count} ({high_value_count/len(prize_values)*100:.1f}%)" ) lines.append( f" 中价值(100-500元): {medium_value_count} ({medium_value_count/len(prize_values)*100:.1f}%)" ) lines.append( f" 低价值(<100元): {low_value_count} ({low_value_count/len(prize_values)*100:.1f}%)" ) lines.append("") # 最近一次福袋信息 fudai_last = stats.get("fudai_last", {}) if fudai_last.get("content") or fudai_last.get("countdown"): lines.append("=" * 60) lines.append("最近一次福袋信息") lines.append("=" * 60) lines.append(f"内容: {fudai_last.get('content') or '-'}") lines.append(f"倒计时: {fudai_last.get('countdown') or '-'}") participants = fudai_last.get("participants") copies = fudai_last.get("copies") if participants is not None and copies is not None: lines.append(f"参与人数/份数: {participants} / {copies}") if participants > 0 and copies > 0: ratio = participants / copies lines.append(f" 中奖概率: {1/ratio*100:.2f}% (1/{ratio:.1f})") prize_value = fudai_last.get("prize_value_yuan") if prize_value is not None: lines.append(f"奖品价值: {prize_value} 元") updated_ts = fudai_last.get("updated_ts") if updated_ts: dt = datetime.fromtimestamp(updated_ts) lines.append("更新时间: " + dt.strftime("%Y-%m-%d %H:%M:%S")) lines.append("") # 中奖记录 wins = stats.get("wins", []) if wins: lines.append("=" * 60) lines.append(f"最近中奖记录(显示最近 {len(wins)} 条)") lines.append("=" * 60) for i, win in enumerate(wins[-10:], 1): # 只显示最近10条 ts = win.get("ts", 0) dt_str = ( datetime.fromtimestamp(ts).strftime("%Y-%m-%d %H:%M:%S") if ts else "-" ) lines.append(f"\n[{i}] 时间: {dt_str}") if win.get("content"): lines.append(f" 内容: {win.get('content')}") if win.get("prize_value_yuan"): lines.append(f" 价值: {win.get('prize_value_yuan')} 元") if win.get("participants") and win.get("copies"): lines.append( f" 人数/份数: {win.get('participants')} / {win.get('copies')}" ) # 确保至少显示基本信息 if not lines: lines.append("=" * 60) lines.append("统计信息") lines.append("=" * 60) lines.append("暂无统计数据") lines.append("") lines.append("提示:请先运行程序以收集统计数据") stats_text.delete("1.0", "end") stats_text.insert("1.0", "\n".join(lines)) except Exception as e: import traceback stats_text.delete("1.0", "end") error_detail = traceback.format_exc() stats_text.insert( "1.0", f"刷新统计信息失败:{e}\n\n详细信息:\n{error_detail}" ) ttk.Button(stats_top, text="刷新", command=refresh_stats).pack(side=LEFT) # 预约队列显示 reservation_top = ttk.Frame(reservation_tab) reservation_top.pack(fill=X, padx=10, pady=(10, 0)) reservation_text = ScrolledText(reservation_tab) reservation_text.pack(fill=BOTH, expand=True, padx=10, pady=10) try: reservation_text.configure(font=("Consolas", 10)) except Exception: pass def refresh_reservations(): try: from path_config import get_reservations_path path = get_reservations_path() except Exception: # 回退到旧路径(向后兼容) import path_config path = path_config.get_reservations_path() try: if os.path.exists(path): with open(path, "r", encoding="utf-8") as f: data = json.load(f) reservation_text.delete("1.0", "end") updated_ts = ( float(data.get("updated_ts", 0.0) or 0.0) if isinstance(data, dict) else 0.0 ) room_pos = ( int(data.get("room_pos", 0) or 0) if isinstance(data, dict) else 0 ) reason = ( str(data.get("reason", "") or "") if isinstance(data, dict) else "" ) current_title = ( str(data.get("current_room_title", "") or "") if isinstance(data, dict) else "" ) current_title_raw = ( str(data.get("current_room_title_raw", "") or "") if isinstance(data, dict) else "" ) reservations = ( data.get("reservations", []) if isinstance(data, dict) else [] ) # 基本信息(中文,更详细) lines = [] lines.append("=" * 60) lines.append("【预约队列总览】") lines.append("=" * 60) if updated_ts > 0: try: updated_dt = datetime.fromtimestamp(updated_ts) updated_str = updated_dt.strftime("%Y年%m月%d日 %H:%M:%S") # 计算距离现在的时间 now_dt = datetime.now() time_diff = now_dt - updated_dt if time_diff.total_seconds() < 60: time_ago = f"{int(time_diff.total_seconds())}秒前" elif time_diff.total_seconds() < 3600: time_ago = f"{int(time_diff.total_seconds() // 60)}分钟前" elif time_diff.total_seconds() < 86400: time_ago = f"{int(time_diff.total_seconds() // 3600)}小时前" else: time_ago = f"{int(time_diff.total_seconds() // 86400)}天前" lines.append(f"最后更新时间:{updated_str} ({time_ago})") except Exception: updated_str = str(updated_ts) lines.append(f"最后更新时间:{updated_str}") else: lines.append("最后更新时间:暂无数据") lines.append( f"当前所在直播间位置:第 {room_pos + 1} 个直播间(索引:{room_pos})" ) lines.append(f"当前直播间名称(清洗后):{current_title or '未知'}") lines.append(f"当前直播间名称(原始):{current_title_raw or '未知'}") lines.append(f"预约队列总数:{len(reservations)} 条") if reason: reason_map = { "record_reservation": "记录新预约", "update_reservation": "更新预约信息", "remove_expired": "移除过期预约", "sort_reservations": "重新排序预约", } reason_text = reason_map.get(reason, reason) lines.append(f"最近更新原因:{reason_text}") lines.append("") # 统计信息 if reservations: now_ts = datetime.now().timestamp() total_value = 0.0 valid_future_times = [] expired_count = 0 upcoming_count = 0 for item in reservations: try: val = float(item.get("prize_value_yuan") or 0.0) total_value += val except Exception: pass ft = float(item.get("future_ts") or 0.0) if ft > 0: valid_future_times.append(ft) remain_sec = ft - now_ts if remain_sec <= 0: expired_count += 1 elif remain_sec <= 300: # 5分钟内 upcoming_count += 1 lines.append("【统计信息】") lines.append(f"预约总价值:{total_value:.2f} 元") if len(reservations) > 0: avg_value = total_value / len(reservations) lines.append(f"平均价值:{avg_value:.2f} 元") if valid_future_times: earliest_ts = min(valid_future_times) latest_ts = max(valid_future_times) try: earliest_str = datetime.fromtimestamp(earliest_ts).strftime( "%Y-%m-%d %H:%M:%S" ) latest_str = datetime.fromtimestamp(latest_ts).strftime( "%Y-%m-%d %H:%M:%S" ) lines.append(f"最早开奖时间:{earliest_str}") lines.append(f"最晚开奖时间:{latest_str}") except Exception: pass if expired_count > 0: lines.append(f"⚠️ 已过期预约:{expired_count} 条") if upcoming_count > 0: lines.append(f"⏰ 即将开奖(5分钟内):{upcoming_count} 条") lines.append("") lines.append("=" * 60) lines.append("【预约明细列表】(按预计开奖时间从早到晚排序)") lines.append("=" * 60) lines.append("") for idx, item in enumerate(reservations, start=1): try: val = float(item.get("prize_value_yuan") or 0.0) except Exception: val = 0.0 content = str(item.get("content") or "") ft = float(item.get("future_ts") or 0.0) ft_str = str(item.get("future_str") or "") pos_seen = int(item.get("pos_seen") or 0) room_title = str(item.get("room_title") or "") room_title_raw = str(item.get("room_title_raw") or "") created_ts = float(item.get("created_ts") or 0.0) # 计算剩余时间(更详细) now_ts = datetime.now().timestamp() remain_sec = ft - now_ts if ft > 0 else 0 if ft <= 0: remain_str = "❌ 开奖时间无效" status_icon = "❌" elif remain_sec <= 0: remain_str = "⏰ 已到开奖时间" status_icon = "⏰" elif remain_sec <= 60: remain_str = f"🔥 即将开奖({int(remain_sec)}秒后)" status_icon = "🔥" elif remain_sec <= 300: remain_str = f"⏰ 即将开奖({int(remain_sec // 60)}分{int(remain_sec % 60)}秒后)" status_icon = "⏰" elif remain_sec <= 3600: remain_str = f"⏳ {int(remain_sec // 60)}分{int(remain_sec % 60)}秒后开奖" status_icon = "⏳" elif remain_sec <= 86400: hours = int(remain_sec // 3600) minutes = int((remain_sec % 3600) // 60) remain_str = f"⏳ {hours}小时{minutes}分钟后开奖" status_icon = "⏳" else: days = int(remain_sec // 86400) hours = int((remain_sec % 86400) // 3600) remain_str = f"📅 {days}天{hours}小时后开奖" status_icon = "📅" # 记录时间(更详细) if created_ts > 0: try: created_dt = datetime.fromtimestamp(created_ts) created_str = created_dt.strftime( "%Y年%m月%d日 %H:%M:%S" ) # 计算距离现在的时间 time_diff = datetime.now() - created_dt if time_diff.total_seconds() < 3600: time_ago = f"{int(time_diff.total_seconds() // 60)}分钟前记录" elif time_diff.total_seconds() < 86400: time_ago = f"{int(time_diff.total_seconds() // 3600)}小时前记录" else: time_ago = f"{int(time_diff.total_seconds() // 86400)}天前记录" created_str_full = f"{created_str} ({time_ago})" except Exception: created_str_full = str(created_ts) else: created_str_full = "未知" # 格式化显示 lines.append( "┌─ 预约 #" + str(idx) + " ─────────────────────────────────────────────" ) lines.append(f"│ 状态:{status_icon} {remain_str}") lines.append("│") lines.append(f"│ 💰 奖品价值:{val:.2f} 元") lines.append(f"│ 📦 奖品内容:{content or '(无描述)'}") lines.append("│") lines.append(f"│ ⏰ 预计开奖时间:{ft_str or '未知'}") if ft > 0: try: ft_dt = datetime.fromtimestamp(ft) ft_str_detailed = ft_dt.strftime( "%Y年%m月%d日 %H:%M:%S" ) if ft_str_detailed != ft_str: lines.append(f"│ 详细时间:{ft_str_detailed}") except Exception: pass lines.append("│") lines.append( f"│ 📍 发现时直播间位置:第 {pos_seen + 1} 个直播间(索引:{pos_seen})" ) lines.append( f"│ 🏠 直播间名称(清洗后):{room_title or '未知'}" ) lines.append( f"│ 🏠 直播间名称(原始):{room_title_raw or '未知'}" ) lines.append(f"│") lines.append(f"│ 📝 记录时间:{created_str_full}") lines.append(f"└{'─' * 58}") lines.append("") else: lines.append("【预约明细列表】") lines.append("") lines.append("暂无预约记录。") lines.append("") lines.append( "提示:当检测到高价值福袋时,系统会自动将其加入预约队列。" ) reservation_text.insert("1.0", "\n".join(lines)) else: reservation_text.delete("1.0", "end") reservation_text.insert("1.0", "暂无预约队列数据") except Exception as e: reservation_text.delete("1.0", "end") reservation_text.insert("1.0", f"读取预约队列失败:{e}") ttk.Button(reservation_top, text="刷新", command=refresh_reservations).pack( side=LEFT ) # 高价值房间显示 high_value_top = ttk.Frame(high_value_tab) high_value_top.pack(fill=X, padx=10, pady=(10, 0)) high_value_text = ScrolledText(high_value_tab) high_value_text.pack(fill=BOTH, expand=True, padx=10, pady=10) try: high_value_text.configure(font=("Consolas", 10)) except Exception: pass def refresh_high_value_rooms(): try: from path_config import get_high_value_rooms_path path = get_high_value_rooms_path() except Exception: # 回退到旧路径(向后兼容) import path_config path = path_config.get_high_value_rooms_path() try: if os.path.exists(path): with open(path, "r", encoding="utf-8") as f: data = json.load(f) high_value_text.delete("1.0", "end") high_value_text.insert( "1.0", json.dumps(data, ensure_ascii=False, indent=2) ) else: high_value_text.delete("1.0", "end") high_value_text.insert("1.0", "暂无高价值房间数据") except Exception as e: high_value_text.delete("1.0", "end") high_value_text.insert("1.0", f"读取高价值房间失败:{e}") ttk.Button(high_value_top, text="刷新", command=refresh_high_value_rooms).pack( side=LEFT ) # 行为日志显示(点击/识别/耗时) actions_log_top = ttk.Frame(actions_log_tab) actions_log_top.pack(fill=X, padx=10, pady=(10, 0)) actions_log_text = ScrolledText(actions_log_tab) actions_log_text.pack(fill=BOTH, expand=True, padx=10, pady=10) try: actions_log_text.configure(font=("Consolas", 10)) except Exception: pass # 配置行为日志颜色标签(使用统一的颜色配置模块) def configure_actions_log_colors(): """根据当前主题配置行为日志的颜色标签""" try: # 获取当前主题 try: current_theme = str(gui_theme_var.get() or "litera") except Exception: current_theme = "litera" # 获取颜色配置 color_config = get_color_config(current_theme) # 根据主题设置背景和前景色 light_themes = {"litera", "flatly", "journal", "minty", "cosmo"} is_light = current_theme.lower() in light_themes if is_light: actions_log_text.configure( background="#FFFFFF", foreground="#2C2C2C", insertbackground="#2C2C2C", ) else: actions_log_text.configure( background="#1E1E1E", foreground="#E0E0E0", insertbackground="#FFFFFF", ) # 为所有操作类型配置标签 for op_type, colors in color_config.items(): tag_name = f"op_{op_type}" try: actions_log_text.tag_configure( tag_name, foreground=colors["foreground"], background=colors["background"], ) except Exception: pass # 忽略标签配置失败 except Exception: pass # 忽略颜色配置失败 # 初始配置 configure_actions_log_colors() actions_filter_var = tk.StringVar(value="") def refresh_actions_log(): """读取 logs/actions.log 的尾部若干行,在 GUI 中展示关键行为日志(支持简单关键字筛选)。""" # 使用统一的路径配置 try: from path_config import get_actions_log_path path = get_actions_log_path() except Exception: # 回退到旧路径(向后兼容) # 修正路径:GUI应该读取根目录的logs/actions.log import path_config path = path_config.get_actions_log_path() try: if os.path.exists(path): # 仿照 web_gui 的实现:只读最后一小段,避免文件巨大 size = os.path.getsize(path) if size == 0: actions_log_text.delete("1.0", "end") actions_log_text.insert("1.0", "行为日志文件为空") return read_bytes = min(size, 65536) with open(path, "rb") as f: if read_bytes < size: f.seek(-read_bytes, os.SEEK_END) data = f.read() # 尝试多种编码方式 try: # 先尝试 utf-8-sig(带BOM) text = data.decode("utf-8-sig", errors="replace") except Exception: try: # 再尝试 utf-8 text = data.decode("utf-8", errors="replace") except Exception: # 最后尝试 gbk(Windows常见编码) text = data.decode("gbk", errors="replace") lines = text.splitlines() # 只取最近 300 行 tail = lines[-300:] # 关键字筛选:若填写了筛选词,只保留包含该关键字的行 kw = actions_filter_var.get().strip() if kw: tail = [ln for ln in tail if kw in ln] # 保存当前滚动位置,避免刷新时自动置顶 try: scroll_position = actions_log_text.yview()[ 0 ] # 获取当前滚动位置(顶部可见位置的比例) except Exception: scroll_position = 0.0 actions_log_text.delete("1.0", "end") if tail: # 获取当前主题(用于颜色配置) try: current_theme = str(gui_theme_var.get() or "litera") except Exception: current_theme = "litera" # 逐行插入并应用颜色标签 for i, line in enumerate(tail): start_pos = actions_log_text.index("end-1c") # 插入行内容 if i > 0: actions_log_text.insert("end", "\n") actions_log_text.insert("end", line) # 使用统一的颜色配置模块应用颜色 end_pos = actions_log_text.index("end") try: apply_operation_color( actions_log_text, start_pos, end_pos, line, current_theme, ) except Exception: pass # 忽略颜色应用失败 else: actions_log_text.insert("1.0", "暂无匹配的行为日志") # 恢复之前的滚动位置,避免自动置顶 try: actions_log_text.yview_moveto(scroll_position) except Exception: pass else: actions_log_text.delete("1.0", "end") actions_log_text.insert( "1.0", "暂无行为日志(logs/actions.log 不存在)" ) except Exception as e: actions_log_text.delete("1.0", "end") actions_log_text.insert("1.0", f"读取行为日志失败:{e}") ttk.Label(actions_log_top, text="关键字筛选:").pack(side=LEFT) ttk.Entry(actions_log_top, textvariable=actions_filter_var, width=16).pack( side=LEFT, padx=(0, 8) ) ttk.Button(actions_log_top, text="刷新", command=refresh_actions_log).pack( side=LEFT, padx=(0, 10) ) # 行为日志搜索功能 ttk.Separator(actions_log_top, orient="vertical").pack( side=LEFT, fill=Y, padx=5, pady=3 ) ttk.Label(actions_log_top, text="搜索:").pack(side=LEFT) actions_search_var = tk.StringVar(value="") actions_search_entry = ttk.Entry( actions_log_top, textvariable=actions_search_var, width=20 ) actions_search_entry.pack(side=LEFT, padx=(0, 5)) actions_search_matches = [] actions_current_match_index = -1 def search_in_actions_log(direction=1): """在行为日志中搜索文本""" nonlocal actions_search_matches, actions_current_match_index search_text = actions_search_var.get().strip() if not search_text: actions_log_text.tag_remove("search_highlight", "1.0", "end") actions_log_text.tag_remove("search_current", "1.0", "end") actions_search_matches = [] actions_current_match_index = -1 return content = actions_log_text.get("1.0", "end-1c") if not content: return actions_log_text.tag_remove("search_highlight", "1.0", "end") actions_log_text.tag_remove("search_current", "1.0", "end") actions_log_text.tag_config("search_highlight", background="yellow") actions_log_text.tag_config("search_current", background="orange") actions_search_matches = [] start_pos = 0 # 使用整数索引 search_text_lower = search_text.lower() content_lower = content.lower() while True: pos = content_lower.find(search_text_lower, start_pos) if pos == -1: break line_start = content[:pos].rfind("\n") + 1 line_num = content[:pos].count("\n") + 1 col_num = pos - line_start start_index = f"{line_num}.{col_num}" end_index = f"{line_num}.{col_num + len(search_text)}" actions_search_matches.append((start_index, end_index)) start_pos = pos + 1 if not actions_search_matches: actions_current_match_index = -1 return for start_idx, end_idx in actions_search_matches: actions_log_text.tag_add("search_highlight", start_idx, end_idx) if direction == 1: actions_current_match_index = (actions_current_match_index + 1) % len( actions_search_matches ) else: actions_current_match_index = (actions_current_match_index - 1) % len( actions_search_matches ) if actions_current_match_index >= 0: start_idx, end_idx = actions_search_matches[actions_current_match_index] actions_log_text.tag_add("search_current", start_idx, end_idx) actions_log_text.see(start_idx) actions_log_text.mark_set("insert", start_idx) def search_next_in_actions(): search_in_actions_log(1) def search_prev_in_actions(): search_in_actions_log(-1) def clear_search_in_actions(): nonlocal actions_search_matches, actions_current_match_index actions_search_var.set("") actions_log_text.tag_remove("search_highlight", "1.0", "end") actions_log_text.tag_remove("search_current", "1.0", "end") actions_search_matches = [] actions_current_match_index = -1 def on_actions_search_entry_key(event): if event.keysym == "Return": search_next_in_actions() actions_search_entry.bind("", on_actions_search_entry_key) ttk.Button(actions_log_top, text="搜索", command=search_next_in_actions).pack( side=LEFT, padx=(0, 2) ) ttk.Button(actions_log_top, text="上一个", command=search_prev_in_actions).pack( side=LEFT, padx=(0, 2) ) ttk.Button(actions_log_top, text="下一个", command=search_next_in_actions).pack( side=LEFT, padx=(0, 2) ) ttk.Button(actions_log_top, text="清除", command=clear_search_in_actions).pack( side=LEFT ) # OCR结果显示 ocr_results_top = ttk.Frame(ocr_results_tab) ocr_results_top.pack(fill=X, padx=10, pady=(10, 0)) ocr_results_text = ScrolledText(ocr_results_tab) ocr_results_text.pack(fill=BOTH, expand=True, padx=10, pady=10) try: ocr_results_text.configure(font=("Consolas", 10)) except Exception: pass def update_ocr_results(results): """更新OCR结果标签页的显示""" try: lines = [] lines.append("=" * 80) lines.append("OCR识别结果(基于最新截图)") lines.append("=" * 80) lines.append("") if not results: lines.append('暂无OCR结果,请先点击"截图+OCR"按钮') else: # 按区域名称分组显示 for region_name, desc, text_result, status in results: lines.append(f"【{region_name}】{desc}") lines.append(f" 状态: {status}") if text_result: # 如果文本较长,分行显示 if len(text_result) > 100: lines.append(f" 识别文本: {text_result[:100]}...") lines.append(f" (完整文本: {text_result})") else: lines.append(f" 识别文本: {text_result}") else: lines.append(" 识别文本: (空)") lines.append("") ocr_results_text.delete("1.0", "end") ocr_results_text.insert("1.0", "\n".join(lines)) ocr_results_text.see("1.0") except Exception as e: ocr_results_text.delete("1.0", "end") ocr_results_text.insert("1.0", f"更新OCR结果失败:{e}") ttk.Button( ocr_results_top, text="刷新", command=lambda: update_ocr_results([]) ).pack(side=LEFT) ttk.Label(ocr_results_top, text='(点击"截图+OCR"按钮自动更新)').pack( side=LEFT, padx=(10, 0) ) # 中奖记录显示 win_record_top = ttk.Frame(win_record_tab) win_record_top.pack(fill=X, padx=10, pady=(10, 0)) win_record_left = ttk.Frame(win_record_tab) win_record_left.pack(side=LEFT, fill=BOTH, expand=True, padx=(10, 5), pady=10) win_record_right = ttk.Frame(win_record_tab) win_record_right.pack( side=RIGHT, fill=BOTH, expand=False, padx=(5, 10), pady=10, ipadx=10 ) # 左侧:中奖截图列表 win_list_label = ttk.Label(win_record_left, text="中奖截图列表:") win_list_label.pack(anchor="w", padx=(0, 10), pady=(0, 5)) win_list_frame = ttk.Frame(win_record_left) win_list_frame.pack(fill=BOTH, expand=True) win_list_scrollbar = ttk.Scrollbar(win_list_frame) win_list_scrollbar.pack(side=RIGHT, fill=Y) win_listbox = tk.Listbox( win_list_frame, yscrollcommand=win_list_scrollbar.set, font=("Consolas", 9) ) win_listbox.pack(side=LEFT, fill=BOTH, expand=True) win_list_scrollbar.config(command=win_listbox.yview) # 存储文件路径映射(索引 -> 文件路径) _win_file_paths: dict[int, str] = {} # 右侧:截图预览 win_preview_label = ttk.Label(win_record_right, text="截图预览:") win_preview_label.pack(anchor="w", pady=(0, 5)) win_preview_frame = ttk.Frame(win_record_right) win_preview_frame.pack(fill=BOTH, expand=True) win_image_label = ttk.Label(win_preview_frame) win_image_label.pack(fill=BOTH, expand=True) _win_img_ref: dict[str, Any] = {"photo": None} def scan_win_images(): """扫描中奖截图目录""" try: from path_config import get_pic_dir pic_dir = get_pic_dir() except Exception: import path_config pic_dir = path_config.get_pic_dir() prize_dir = os.path.join(pic_dir, "lottery_prize_captures") win_images = [] if os.path.exists(prize_dir): for file in os.listdir(prize_dir): if file.lower().endswith((".png", ".jpg", ".jpeg")): file_path = os.path.join(prize_dir, file) # 获取文件修改时间 try: mtime = os.path.getmtime(file_path) win_images.append((file, file_path, mtime)) except Exception: win_images.append((file, file_path, 0)) # 按时间倒序排序(最新的在前) win_images.sort(key=lambda x: x[2], reverse=True) return win_images def refresh_win_record(): """刷新中奖记录列表""" try: win_images = scan_win_images() win_listbox.delete(0, tk.END) _win_file_paths.clear() for idx, (file, file_path, mtime) in enumerate(win_images): # 格式化显示:文件名 + 时间 try: dt = datetime.fromtimestamp(mtime) time_str = dt.strftime("%Y-%m-%d %H:%M:%S") display_text = f"{file} ({time_str})" except Exception: display_text = file win_listbox.insert(tk.END, display_text) # 存储文件路径映射 _win_file_paths[idx] = file_path if win_images: on_line(f"[中奖记录] 扫描到 {len(win_images)} 张中奖截图") else: on_line("[中奖记录] 暂无中奖截图") except Exception as e: on_line(f"[中奖记录] 刷新失败:{e}") def on_win_list_select(event): """当选择中奖截图时,显示预览""" try: selection = win_listbox.curselection() if not selection: return index = selection[0] # 从映射中获取文件路径 if index in _win_file_paths: file_path = _win_file_paths[index] _load_win_image(file_path) except Exception as e: on_line(f"[中奖记录] 预览失败:{e}") def _load_win_image(img_path: str): """加载并显示中奖截图""" if not os.path.exists(img_path): win_image_label.configure(image="") _win_img_ref["photo"] = None return try: img = Image.open(img_path) img.load() img = img.convert("RGB") except Exception as e: on_line(f"[中奖记录] 图片加载失败:{e}") return # 获取预览区域尺寸 try: win_preview_frame.update_idletasks() w = win_preview_frame.winfo_width() h = win_preview_frame.winfo_height() if w <= 1 or h <= 1: w, h = 400, 600 except Exception: w, h = 400, 600 max_w = max(200, w - 20) max_h = max(300, h - 20) try: resample = Image.Resampling.LANCZOS except AttributeError: resample = 1 img.thumbnail((max_w, max_h), resample) photo = ImageTk.PhotoImage(img) _win_img_ref["photo"] = photo win_image_label.configure(image=photo) win_listbox.bind("<>", on_win_list_select) ttk.Button(win_record_top, text="刷新列表", command=refresh_win_record).pack( side=LEFT, padx=(0, 10) ) def open_win_folder(): """打开中奖截图目录""" try: from path_config import get_pic_dir pic_dir = get_pic_dir() except Exception: import path_config pic_dir = path_config.get_pic_dir() prize_dir = os.path.join(pic_dir, "lottery_prize_captures") os.makedirs(prize_dir, exist_ok=True) try: os.startfile(prize_dir) # type: ignore[attr-defined] except Exception as e: on_line(f"[中奖记录] 打开目录失败:{e}") ttk.Button(win_record_top, text="打开目录", command=open_win_folder).pack(side=LEFT) ttk.Button( win_record_top, text="实时查看", command=lambda: open_realtime_viewer() ).pack(side=LEFT, padx=(8, 0)) # 误识别记录管理 false_positive_frame = ttk.LabelFrame(win_record_right, text="误识别记录管理") false_positive_frame.pack(fill=X, pady=(10, 0)) false_positive_text = ScrolledText(false_positive_frame, height=6) false_positive_text.pack(fill=X, padx=10, pady=10) def load_false_positives(): """加载误识别记录""" try: from path_config import get_pic_dir pic_dir = get_pic_dir() except Exception: import path_config pic_dir = path_config.get_pic_dir() false_positive_file = os.path.join( pic_dir, "lottery_prize_captures", "false_positives.json" ) if not os.path.exists(false_positive_file): false_positive_text.delete("1.0", "end") false_positive_text.insert("1.0", "暂无误识别记录") return try: with open(false_positive_file, "r", encoding="utf-8") as f: data = json.load(f) false_positives = data.get("false_positives", []) false_positive_text.delete("1.0", "end") if false_positives: false_positive_text.insert("1.0", "\n".join(false_positives)) else: false_positive_text.insert("1.0", "暂无误识别记录") except Exception as e: false_positive_text.delete("1.0", "end") false_positive_text.insert("1.0", f"加载失败:{e}") def save_false_positives(): """保存误识别记录""" try: from path_config import get_pic_dir pic_dir = get_pic_dir() except Exception: import path_config pic_dir = path_config.get_pic_dir() false_positive_file = os.path.join( pic_dir, "lottery_prize_captures", "false_positives.json" ) os.makedirs(os.path.dirname(false_positive_file), exist_ok=True) content = false_positive_text.get("1.0", "end-1c") lines = [line.strip() for line in content.splitlines() if line.strip()] try: with open(false_positive_file, "w", encoding="utf-8") as f: json.dump({"false_positives": lines}, f, ensure_ascii=False, indent=2) on_line(f"[中奖记录] 已保存 {len(lines)} 条误识别记录") except Exception as e: on_line(f"[中奖记录] 保存失败:{e}") false_positive_btn_frame = ttk.Frame(false_positive_frame) false_positive_btn_frame.pack(fill=X, padx=10, pady=(0, 10)) ttk.Button( false_positive_btn_frame, text="刷新", command=load_false_positives ).pack(side=LEFT, padx=(0, 5)) ttk.Button( false_positive_btn_frame, text="保存", command=save_false_positives ).pack(side=LEFT) load_false_positives() pump_logs() def delayed_refresh_preview() -> None: if image_var.get(): refresh_preview() root.after(300, delayed_refresh_preview) # type: ignore[arg-type] root.after(500, refresh_stats) # type: ignore[arg-type] root.after(500, refresh_reservations) # type: ignore[arg-type] root.after(500, refresh_high_value_rooms) # type: ignore[arg-type] root.after(500, refresh_actions_log) # type: ignore[arg-type] root.after(500, refresh_win_record) # type: ignore[arg-type] # 定期刷新行为日志(每2秒) def auto_refresh_actions_log() -> None: refresh_actions_log() root.after(2000, auto_refresh_actions_log) # type: ignore[arg-type] # 定期刷新预约队列(每5秒) def auto_refresh_reservations() -> None: refresh_reservations() root.after(5000, auto_refresh_reservations) # type: ignore[arg-type] root.after(2000, auto_refresh_actions_log) # type: ignore[arg-type] root.after(5000, auto_refresh_reservations) # type: ignore[arg-type] # 定期刷新统计信息(每3秒) def auto_refresh_stats() -> None: if runner.is_running(): refresh_stats() root.after(3000, auto_refresh_stats) # type: ignore[arg-type] auto_refresh_stats() def on_close(): try: runner.stop() except Exception: pass root.destroy() root.protocol("WM_DELETE_WINDOW", on_close) refresh_devices() root.mainloop() if __name__ == "__main__": try: from version import print_version_banner print_version_banner("gui_app") except Exception: pass main()