Files
douyin_guaji-main/gui/gui_app.py
T

4448 lines
181 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
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_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))
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(
"<Configure>",
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("<MouseWheel>", _on_mousewheel)
debug_canvas.bind_all("<Shift-MouseWheel>", _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_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_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
from PIL import Image
import os
# 使用 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)
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)
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(ocr_results_tab, text="OCR结果")
notebook.add(win_record_tab, text="中奖记录")
# 日志区
log_box = ttk.Frame(log_tab)
log_box.pack(fill=BOTH, expand=True)
# 搜索工具栏
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("<KeyPress>", 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(
"<<ComboboxSelected>>", 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
),
)
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:
import datetime
dt = datetime.datetime.fromtimestamp(last_log_ts)
lines.append(f"最近日志时间: {dt.strftime('%Y-%m-%d %H:%M:%S')}")
else:
lines.append(f"最近日志时间: -")
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:
import datetime
dt = datetime.datetime.fromtimestamp(updated_ts)
lines.append(f"更新时间: {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条
import datetime
ts = win.get("ts", 0)
dt_str = (
datetime.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")
from datetime import datetime
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(
f"┌─ 预约 #{idx} ─────────────────────────────────────────────"
)
lines.append(f"│ 状态:{status_icon} {remain_str}")
lines.append(f"│")
lines.append(f"│ 💰 奖品价值:{val:.2f} 元")
lines.append(f"│ 📦 奖品内容:{content or '(无描述)'}")
lines.append(f"│")
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(f"│")
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("<KeyPress>", 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:
from datetime import datetime
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("<<ListboxSelect>>", 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)
# 误识别记录管理
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:
import json
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:
import json
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()