Files
douyi_guaji_main/gui/gui_app.py
T

5734 lines
231 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 # type: ignore[import]
# 抽离:ADB/配置/参数结构体到 gui_core.py(便于后续模块化)
from gui.gui_core import (
RunParams,
Runner,
find_adb_executable,
list_adb_devices,
enable_wifi_adb,
connect_wifi_adb,
disconnect_wifi_adb,
get_device_ip,
auto_connect_wifi_adb,
is_device_wifi_connected,
get_connected_wifi_devices,
read_config,
write_config,
)
from path_config import get_logs_dir
from gui.components.mapping_table import create_mapping_tab
# 导入日志颜色配置模块
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 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()
# 常量兜底:部分主题常量未提供时使用字符串
BOTTOM = "bottom"
# W 常量在部分导入路径中可能不存在,兜底为 'w'(grid sticky 使用)
W = "w"
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 状态设备(可能未授权/未连接)")
def save_logging_config():
"""保存日志配置到配置文件"""
try:
# 读取当前配置
cfg = read_config()
# 更新日志相关配置
if "logging" not in cfg:
cfg["logging"] = {}
cfg["logging"]["log_format_mode"] = logging_format_mode_var.get()
cfg["logging"]["beautify_output"] = bool(logging_beautify_var.get())
cfg["logging"]["color_output"] = bool(logging_color_var.get())
cfg["logging"]["show_timestamps"] = bool(logging_show_timestamps_var.get())
cfg["logging"]["debug_detail_level"] = logging_debug_level_var.get()
cfg["logging"]["error_detail_level"] = logging_error_level_var.get()
cfg["logging"]["action_log_format"] = logging_action_format_var.get()
cfg["logging"]["enable_monitor"] = bool(logging_enable_monitor_var.get())
cfg["logging"]["keep_days"] = int(logging_keep_days_var.get())
cfg["logging"]["compress_logs"] = bool(logging_compress_logs_var.get())
cfg["logging"]["max_total_size_gb"] = float(
logging_max_total_size_gb_var.get()
)
cfg["logging"]["compress_after_days"] = int(
logging_compress_after_days_var.get()
)
cfg["logging"]["monitor_warning_mb"] = float(
logging_monitor_warning_mb_var.get()
)
cfg["logging"]["monitor_critical_mb"] = float(
logging_monitor_critical_mb_var.get()
)
cfg["logging"]["performance_tracking"] = {
"enabled": bool(logging_performance_enabled_var.get()),
"track_function_calls": bool(logging_track_functions_var.get()),
}
# 更新GUI主题
if "gui" not in cfg:
cfg["gui"] = {}
cfg["gui"]["theme"] = gui_theme_var.get()
# 保存配置
write_config(cfg)
on_line("[配置] 日志配置已保存")
except Exception as e:
on_line(f"[配置] 保存日志配置失败:{e}")
refresh_devices_btn = ttk.Button(top, text="刷新设备", command=refresh_devices)
refresh_devices_btn.pack(side=LEFT, padx=(0, 20))
# WiFi ADB 功能
def open_wifi_adb_dialog():
"""打开WiFi ADB设置对话框"""
dialog = tk.Toplevel(root)
dialog.title("WiFi ADB 设置")
dialog.geometry("500x450")
# 允许用户调整对话框大小,避免窗口内容被裁剪
dialog.resizable(True, True)
dialog.minsize(420, 320)
# 获取设备列表并分类
current_devices = list_adb_devices(adb_exe)
wifi_devices = get_connected_wifi_devices(adb_exe)
usb_devices = [d for d in current_devices if d not in wifi_devices]
# 创建设备选择区域
device_frame = ttk.LabelFrame(dialog, text="设备选择", padding=10)
device_frame.pack(fill=X, padx=10, pady=10)
# 使内部 grid 列随窗口宽度伸缩
device_frame.grid_columnconfigure(0, weight=3)
device_frame.grid_columnconfigure(1, weight=1)
# USB设备选择
ttk.Label(device_frame, text="USB设备(用于首次启用):").grid(
row=0, column=0, sticky=W, pady=(0, 5)
)
usb_device_var = tk.StringVar(value=(usb_devices[0] if usb_devices else ""))
usb_combo = ttk.Combobox(
device_frame,
textvariable=usb_device_var,
values=usb_devices,
width=25,
state="readonly" if not usb_devices else "normal",
)
usb_combo.grid(row=1, column=0, padx=(0, 10), pady=(0, 10), sticky="we")
# 显示USB设备状态
usb_status_text = (
f"检测到 {len(usb_devices)} 个USB设备"
if usb_devices
else "未检测到USB设备,请确保设备已连接并授权"
)
usb_status_label = ttk.Label(
device_frame,
text=usb_status_text,
font=("Arial", 8),
foreground="red" if not usb_devices else "green",
)
usb_status_label.grid(row=2, column=0, sticky=W, pady=(0, 10))
# WiFi设备选择
ttk.Label(device_frame, text="WiFi设备(已连接):").grid(
row=0, column=1, sticky=W, pady=(0, 5)
)
wifi_device_var = tk.StringVar(value=(wifi_devices[0] if wifi_devices else ""))
wifi_combo = ttk.Combobox(
device_frame,
textvariable=wifi_device_var,
values=wifi_devices,
width=25,
state="readonly" if not wifi_devices else "normal",
)
wifi_combo.grid(row=1, column=1, pady=(0, 10), sticky="we")
# 显示WiFi设备状态
wifi_status_text = (
f"已连接 {len(wifi_devices)} 个WiFi设备"
if wifi_devices
else "无WiFi设备连接"
)
wifi_status_label = ttk.Label(
device_frame,
text=wifi_status_text,
font=("Arial", 8),
foreground="blue" if wifi_devices else "gray",
)
wifi_status_label.grid(row=2, column=1, sticky=W, pady=(0, 10))
# IP地址输入区域
ip_frame = ttk.LabelFrame(dialog, text="连接信息", padding=10)
ip_frame.pack(fill=X, padx=10, pady=(0, 10))
# 使 IP/端口 输入框随窗口宽度伸缩
ip_frame.grid_columnconfigure(0, weight=3)
ip_frame.grid_columnconfigure(1, weight=1)
ttk.Label(ip_frame, text="设备IP地址:").grid(
row=0, column=0, sticky=W, pady=(0, 5)
)
ip_var = tk.StringVar()
ip_entry = ttk.Entry(ip_frame, textvariable=ip_var, width=25)
ip_entry.grid(row=1, column=0, padx=(0, 10), pady=(0, 10), sticky="we")
ttk.Label(ip_frame, text="端口(默认5555):").grid(
row=0, column=1, sticky=W, pady=(0, 5)
)
port_var = tk.StringVar(value="5555")
port_entry = ttk.Entry(ip_frame, textvariable=port_var, width=25)
port_entry.grid(row=1, column=1, pady=(0, 10), sticky="we")
# 按钮区域
button_frame = ttk.Frame(dialog)
button_frame.pack(fill=X, padx=10, pady=10)
def enable_wifi():
device_id = usb_device_var.get()
if not device_id:
on_line("[WiFi ADB] 请先选择USB设备")
return
success, msg = enable_wifi_adb(adb_exe, device_id)
on_line(f"[WiFi ADB] {msg}")
if success:
# 尝试获取IP地址
ip_success, ip_msg = get_device_ip(adb_exe, device_id)
if ip_success:
ip_var.set(ip_msg)
on_line(f"[WiFi ADB] 设备IP地址: {ip_msg}")
def connect_wifi():
ip = ip_var.get().strip()
port = port_var.get().strip()
if not ip:
on_line("[WiFi ADB] 请输入IP地址")
return
success, msg = connect_wifi_adb(adb_exe, ip, port)
on_line(f"[WiFi ADB] {msg}")
if success:
# 刷新设备列表
refresh_devices()
# 重新打开对话框以显示新的WiFi设备
dialog.destroy()
open_wifi_adb_dialog()
def disconnect_wifi():
device_id = wifi_device_var.get()
if not device_id:
on_line("[WiFi ADB] 请先选择WiFi设备")
return
# 从设备ID中提取IP地址
ip_match = re.search(r"(\d+\.\d+\.\d+\.\d+)", device_id)
if not ip_match:
on_line("[WiFi ADB] 无法从设备ID中提取IP地址")
return
ip = ip_match.group(1)
success, msg = disconnect_wifi_adb(adb_exe, ip, "5555")
on_line(f"[WiFi ADB] {msg}")
if success:
# 刷新设备列表
refresh_devices()
# 重新打开对话框以更新设备列表
dialog.destroy()
open_wifi_adb_dialog()
def auto_connect_wifi():
device_id = usb_device_var.get()
if not device_id:
on_line("[WiFi ADB] 请先选择USB设备")
return
# 显示进度
on_line("[WiFi ADB] 开始自动连接...")
# 创建进度对话框
progress_dialog = tk.Toplevel(dialog)
progress_dialog.title("自动连接中...")
progress_dialog.geometry("300x120")
progress_dialog.resizable(False, False)
ttk.Label(progress_dialog, text="正在自动连接WiFi ADB,请稍候...").pack(
pady=10
)
ttk.Label(progress_dialog, text="设备将会重启,请等待重启完成").pack(
pady=(0, 10)
)
progress_bar = ttk.Progressbar(progress_dialog, mode="indeterminate")
progress_bar.pack(fill=X, padx=20, pady=(0, 20))
progress_bar.start()
def do_auto_connect():
try:
success, msg = auto_connect_wifi_adb(adb_exe, device_id)
progress_dialog.destroy()
on_line(f"[WiFi ADB] {msg}")
if success:
# 刷新设备列表
refresh_devices()
# 尝试获取并显示IP
ip_success, ip_msg = get_device_ip(adb_exe, device_id)
if ip_success:
ip_var.set(ip_msg)
# 重新打开对话框以显示新的WiFi设备
dialog.destroy()
open_wifi_adb_dialog()
except Exception as e:
progress_dialog.destroy()
on_line(f"[WiFi ADB] 自动连接异常: {str(e)}")
# 在后台线程中执行自动连接
threading.Thread(target=do_auto_connect, daemon=True).start()
# 放大/恢复窗口支持(当系统边框无法调整窗口时提供备用按钮)
is_maximized = False
original_geometry = None
def toggle_maximize():
nonlocal is_maximized, original_geometry
try:
if not is_maximized:
original_geometry = dialog.geometry()
dialog.update_idletasks()
w = int(dialog.winfo_screenwidth() * 0.8)
h = int(dialog.winfo_screenheight() * 0.8)
dialog.geometry(f"{w}x{h}")
is_maximized = True
else:
if original_geometry:
dialog.geometry(original_geometry)
is_maximized = False
except Exception as e:
on_line(f"[WiFi ADB] 切换窗口大小失败: {e}")
def refresh_device_lists():
"""刷新设备列表"""
nonlocal usb_devices, wifi_devices
current_devices = list_adb_devices(adb_exe)
wifi_devices = get_connected_wifi_devices(adb_exe)
usb_devices = [d for d in current_devices if d not in wifi_devices]
# 更新USB设备下拉框
usb_combo["values"] = usb_devices
usb_combo["state"] = "readonly" if not usb_devices else "normal"
if usb_devices:
usb_device_var.set(usb_devices[0])
else:
usb_device_var.set("")
# 更新WiFi设备下拉框
wifi_combo["values"] = wifi_devices
wifi_combo["state"] = "readonly" if not wifi_devices else "normal"
if wifi_devices:
wifi_device_var.set(wifi_devices[0])
else:
wifi_device_var.set("")
# 更新状态标签
usb_status_text = (
f"检测到 {len(usb_devices)} 个USB设备"
if usb_devices
else "未检测到USB设备,请确保设备已连接并授权"
)
usb_status_label.config(
text=usb_status_text, foreground="red" if not usb_devices else "green"
)
wifi_status_text = (
f"已连接 {len(wifi_devices)} 个WiFi设备"
if wifi_devices
else "无WiFi设备连接"
)
wifi_status_label.config(
text=wifi_status_text, foreground="blue" if wifi_devices else "gray"
)
on_line("[WiFi ADB] 设备列表已刷新")
# USB设备操作按钮
usb_button_frame = ttk.Frame(button_frame)
usb_button_frame.pack(fill=X, pady=(0, 10))
ttk.Label(usb_button_frame, text="USB设备操作:").pack(anchor=W)
usb_buttons_frame = ttk.Frame(usb_button_frame)
usb_buttons_frame.pack(fill=X, pady=(5, 0))
ttk.Button(usb_buttons_frame, text="自动连接", command=auto_connect_wifi).pack(
side=LEFT, padx=(0, 10)
)
ttk.Button(usb_buttons_frame, text="启用WiFi ADB", command=enable_wifi).pack(
side=LEFT, padx=(0, 10)
)
ttk.Button(usb_buttons_frame, text="连接", command=connect_wifi).pack(
side=LEFT, padx=(0, 10)
)
ttk.Button(
usb_buttons_frame, text="刷新设备", command=refresh_device_lists
).pack(side=LEFT)
# 如果窗口无法通过边框调整,提供放大/恢复按钮作为备用
ttk.Button(usb_buttons_frame, text="放大/恢复", command=toggle_maximize).pack(
side=LEFT, padx=(8, 0)
)
# WiFi设备操作按钮
wifi_button_frame = ttk.Frame(button_frame)
wifi_button_frame.pack(fill=X, pady=(10, 0))
ttk.Label(wifi_button_frame, text="WiFi设备操作:").pack(anchor=W)
wifi_buttons_frame = ttk.Frame(wifi_button_frame)
wifi_buttons_frame.pack(fill=X, pady=(5, 0))
ttk.Button(wifi_buttons_frame, text="断开连接", command=disconnect_wifi).pack(
side=LEFT
)
# 说明文本
info_text = """重要说明:
• Android系统安全要求:首次启用WiFi ADB必须通过USB连接
• 工作流程:USB连接 → 启用WiFi ADB → 设备重启 → WiFi连接
• 设置完成后,设备会出现在"WiFi设备"列表中,无需再次USB连接
• 设备重启后WiFi ADB模式会保持,可直接通过WiFi连接使用
使用方法:
1. 连接Android设备到电脑(USB)
2. 点击"刷新设备"确保设备被检测到
3. 选择USB设备,点击"自动连接"或手动操作
4. 等待设备重启后即可通过WiFi使用"""
info_label = ttk.Label(
dialog, text=info_text, justify=LEFT, font=("Arial", 9), wraplength=460
)
info_label.pack(pady=(10, 0), padx=20, anchor="w")
wifi_adb_btn = ttk.Button(top, text="WiFi ADB", command=open_wifi_adb_dialog)
wifi_adb_btn.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)
)
# 连续无福袋退出阈值变量(提前声明,实际声明在下方唯一位置以便与配置同步)
# (变量将在后面统一声明,避免重复创建 IntVar 导致绑定不一致)
# 启用返回键回退开关变量(提前声明)
enable_back_on_misses_var = tk.BooleanVar(
value=bool(cfg.get("enable_back_on_misses", True))
)
# 中部:左侧配置(使用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) # 右侧日志/预览区域
# 右侧为日志/预览区域(保持原样)
# right_notebook previously added here; mapping tab will attach to the left notebook
# 左侧使用Notebook标签页组织配置
left_notebook = ttk.Notebook(left_wrap)
left_notebook.pack(fill=BOTH, expand=True)
# 左侧 Notebook 中不再添加映射表页(已移至右侧)
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)
)
reset_after_swipes_action_var = tk.StringVar(
value=str(cfg.get("reset_after_swipes_action", "swipe") or "swipe")
)
enable_back_on_misses_var = tk.BooleanVar(
value=bool(cfg.get("enable_back_on_misses", True))
)
# 流式后台截图开关(默认启用)
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", 300) or 300)
)
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_fudai_poll_before_seconds_var = tk.DoubleVar(
value=float(cfg.get("high_value_fudai_poll_before_seconds", 10.0) or 10.0)
)
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))
)
high_value_room_revisit_min_interval_seconds_var = tk.IntVar(
value=int(cfg.get("high_value_room_revisit_min_interval_seconds", 300))
)
high_value_room_revisit_max_per_run_var = tk.IntVar(
value=int(cfg.get("high_value_room_revisit_max_per_run", 5))
)
high_value_room_revisit_min_prize_value_var = tk.DoubleVar(
value=float(cfg.get("high_value_room_revisit_min_prize_value", 0.0))
)
high_value_room_revisit_max_age_days_var = tk.IntVar(
value=int(cfg.get("high_value_room_revisit_max_age_days", 30))
)
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_back_verify_wait_seconds_var = tk.DoubleVar(
value=float(cfg.get("reservation_back_verify_wait_seconds", 5.0) or 5.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)
)
# 滑动坐标配置
swipe_up_start_y_var = tk.IntVar(
value=int(cfg.get("swipe_up_start_y", 1200) or 1200)
)
swipe_up_end_y_var = tk.IntVar(value=int(cfg.get("swipe_up_end_y", 600) or 600))
# 推荐页养号:爱心/收藏/评论(基于图标模板匹配 + 坐标点击)
yg_enabled_var = tk.BooleanVar(value=bool(cfg.get("yanghao_enabled", True)))
yg_actions_enabled_var = tk.BooleanVar(
value=bool(cfg.get("yanghao_enable_actions", True))
)
yg_only_var = tk.BooleanVar(value=bool(cfg.get("yanghao_only", False)))
yg_recommend_duration_var = tk.IntVar(
value=int(cfg.get("yanghao_recommend_duration_seconds", 60) or 60)
)
yg_recommend_interval_var = tk.IntVar(
value=int(cfg.get("yanghao_recommend_interval_seconds", 0) or 0)
)
yg_like_prob_var = tk.DoubleVar(
value=float(cfg.get("yanghao_like_prob", 0.0) or 0.0)
)
yg_fav_prob_var = tk.DoubleVar(value=float(cfg.get("yanghao_fav_prob", 0.0) or 0.0))
yg_comment_prob_var = tk.DoubleVar(
value=float(cfg.get("yanghao_comment_prob", 0.0) or 0.0)
)
yg_dwell_on_action_min_var = tk.DoubleVar(
value=float(cfg.get("yanghao_dwell_on_action_min_seconds", 5) or 5)
)
yg_dwell_on_action_max_var = tk.DoubleVar(
value=float(cfg.get("yanghao_dwell_on_action_max_seconds", 30) or 30)
)
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_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_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)
)
stage_diag_verbose_var = tk.BooleanVar(
value=bool(cfg.get("logging", {}).get("stage_diag_verbose", True))
)
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)
)
# 购物红包背景红色占比阈值(0.0~1.0,默认0.15)
shopping_redpacket_red_ratio_threshold_var = tk.DoubleVar(
value=float(cfg.get("shopping_redpacket_red_ratio_threshold", 0.15) or 0.15)
)
# 调试图像开关 & 清理相关变量
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_enable_monitor_var = tk.BooleanVar(
value=bool(cfg.get("logging", {}).get("enable_monitor", True))
)
logging_keep_days_var = tk.IntVar(
value=int(cfg.get("logging", {}).get("keep_days", 30) or 30)
)
logging_compress_logs_var = tk.BooleanVar(
value=bool(cfg.get("logging", {}).get("compress_logs", True))
)
logging_max_total_size_gb_var = tk.DoubleVar(
value=float(cfg.get("logging", {}).get("max_total_size_gb", 10.0) or 10.0)
)
logging_compress_after_days_var = tk.IntVar(
value=int(cfg.get("logging", {}).get("compress_after_days", 7) or 7)
)
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"))
)
logging_format_mode_var = tk.StringVar(
value=str(cfg.get("logging", {}).get("log_format_mode", "simple"))
)
logging_monitor_warning_mb_var = tk.DoubleVar(
value=float(cfg.get("logging", {}).get("monitor_warning_mb", 500.0) or 500.0)
)
logging_monitor_critical_mb_var = tk.DoubleVar(
value=float(cfg.get("logging", {}).get("monitor_critical_mb", 2000.0) or 2000.0)
)
# 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, 6))
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))
# r2_5: 滑动重置回退方式(与滑动重置配置放在一起)
r2_5 = ttk.Frame(run_box)
r2_5.pack(fill=X, padx=10, pady=(0, 10))
ttk.Label(r2_5, text="滑动重置回退方式:").pack(side=LEFT)
ttk.Combobox(
r2_5,
values=["swipe", "back"],
textvariable=reset_after_swipes_action_var,
state="readonly",
width=8,
).pack(side=LEFT, padx=(6, 0))
ttk.Label(r2_5, text="(滑动次数重置时的回退方法)").pack(side=LEFT, padx=(6, 0))
# r3: 启用返回键回退(单独一行)
r3 = ttk.Frame(run_box)
r3.pack(fill=X, padx=10, pady=(0, 6))
ttk.Checkbutton(
r3,
text="启用返回键回退",
variable=enable_back_on_misses_var,
).pack(side=LEFT)
# r4: 连续无福袋退出阈值(放在启用回退下一行,便于查看)
r4 = ttk.Frame(run_box)
r4.pack(fill=X, padx=10, pady=(0, 10))
ttk.Label(r4, text="连续无福袋退出阈值:").pack(side=LEFT)
ttk.Spinbox(
r4, from_=1, to=99999, textvariable=fudai_exit_after_misses_var, width=6
).pack(side=LEFT, padx=(6, 12))
# 标签页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=0.01,
format="%.2f",
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_r4a = ttk.Frame(reservation_box)
res_r4a.pack(fill=X, padx=10, pady=(0, 8))
ttk.Label(res_r4a, text="重访最小间隔(秒):").pack(side=LEFT)
ttk.Spinbox(
res_r4a,
from_=60,
to=3600,
textvariable=high_value_room_revisit_min_interval_seconds_var,
width=8,
).pack(side=LEFT, padx=(0, 20))
ttk.Label(res_r4a, text="每次运行最大次数:").pack(side=LEFT)
ttk.Spinbox(
res_r4a,
from_=1,
to=20,
textvariable=high_value_room_revisit_max_per_run_var,
width=5,
).pack(side=LEFT, padx=(0, 20))
res_r4b = ttk.Frame(reservation_box)
res_r4b.pack(fill=X, padx=10, pady=(0, 8))
ttk.Label(res_r4b, text="最低奖品价值(元):").pack(side=LEFT)
ttk.Spinbox(
res_r4b,
from_=0.0,
to=10000.0,
textvariable=high_value_room_revisit_min_prize_value_var,
width=8,
).pack(side=LEFT, padx=(0, 20))
ttk.Label(res_r4b, text="最大年龄(天):").pack(side=LEFT)
ttk.Spinbox(
res_r4b,
from_=1,
to=365,
textvariable=high_value_room_revisit_max_age_days_var,
width=5,
).pack(side=LEFT, padx=(0, 20))
# 开奖前轮询时间
res_r4b = ttk.Frame(reservation_box)
res_r4b.pack(fill=X, padx=10, pady=(0, 8))
ttk.Label(res_r4b, text="开奖前轮询时间(秒):").pack(side=LEFT)
ttk.Spinbox(
res_r4b,
from_=0.0,
to=60.0,
increment=1.0,
textvariable=high_value_fudai_poll_before_seconds_var,
width=6,
).pack(side=LEFT)
ttk.Label(res_r4b, text="(开奖前N秒开始轮询预约)").pack(side=LEFT, padx=(6, 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.1,
to=10.0,
increment=0.1,
textvariable=reservation_back_verify_wait_seconds_var,
width=8,
).pack(side=LEFT)
# 养号设置标签(后续代码)
yanghao_tab = ttk.Frame(left_notebook)
left_notebook.add(yanghao_tab, text="养号设置")
yg_box = ttk.LabelFrame(yanghao_tab, text="推荐页养号(爱心/收藏/评论)")
yg_box.pack(fill=X, padx=10, pady=(10, 10))
yg_switch = ttk.Frame(yg_box)
yg_switch.pack(fill=X, padx=10, pady=(10, 6))
ttk.Checkbutton(
yg_switch, text="养号总开关(关闭则跳过推荐页养号)", variable=yg_enabled_var
).pack(side=LEFT)
ttk.Checkbutton(
yg_switch,
text="启用养号动作(爱心/收藏/评论)",
variable=yg_actions_enabled_var,
).pack(side=LEFT, padx=(10, 0))
ttk.Checkbutton(
yg_switch,
text="只养号(仅执行推荐页养号,跳过抽奖/参与)",
variable=yg_only_var,
).pack(side=LEFT, padx=(10, 0))
yg0 = ttk.Frame(yg_box)
yg0.pack(fill=X, padx=10, pady=(0, 8))
ttk.Checkbutton(
yg0,
text="逐步截图(调试用,生成 pic/*/latest.png)",
variable=yg_step_screenshot_var,
).pack(side=LEFT)
yg_time = ttk.Frame(yg_box)
yg_time.pack(fill=X, padx=10, pady=(0, 8))
ttk.Label(yg_time, text="养号时长(秒):").pack(side=LEFT)
ttk.Spinbox(
yg_time,
from_=1,
to=3600,
increment=5,
textvariable=yg_recommend_duration_var,
width=8,
).pack(side=LEFT)
ttk.Label(yg_time, text="养号间隔(秒):").pack(side=LEFT, padx=(12, 0))
ttk.Spinbox(
yg_time,
from_=0,
to=3600,
increment=10,
textvariable=yg_recommend_interval_var,
width=8,
).pack(side=LEFT)
ttk.Label(yg_time, text="(0=每次触发都执行)").pack(side=LEFT, padx=(6, 0))
yg1 = ttk.Frame(yg_box)
yg1.pack(fill=X, padx=10, pady=(0, 8))
ttk.Label(yg1, text="爱心概率:").pack(side=LEFT)
ttk.Spinbox(
yg1, from_=0.0, to=1.0, increment=0.05, textvariable=yg_like_prob_var, width=6
).pack(side=LEFT)
ttk.Label(yg1, text="收藏概率:").pack(side=LEFT, padx=(10, 0))
ttk.Spinbox(
yg1, from_=0.0, to=1.0, increment=0.05, textvariable=yg_fav_prob_var, width=6
).pack(side=LEFT)
ttk.Label(yg1, text="评论概率:").pack(side=LEFT, padx=(10, 0))
ttk.Spinbox(
yg1,
from_=0.0,
to=1.0,
increment=0.05,
textvariable=yg_comment_prob_var,
width=6,
).pack(side=LEFT)
ttk.Label(yg1, text="(0~1)").pack(side=LEFT, padx=(6, 0))
yg1b = ttk.Frame(yg_box)
yg1b.pack(fill=X, padx=10, pady=(0, 8))
ttk.Label(yg1b, text="检测动作后停留(秒):").pack(side=LEFT)
ttk.Spinbox(
yg1b,
from_=0.0,
to=120.0,
increment=1.0,
textvariable=yg_dwell_on_action_min_var,
width=6,
).pack(side=LEFT)
ttk.Label(yg1b, text="~").pack(side=LEFT, padx=(6, 6))
ttk.Spinbox(
yg1b,
from_=0.0,
to=120.0,
increment=1.0,
textvariable=yg_dwell_on_action_max_var,
width=6,
).pack(side=LEFT)
ttk.Label(yg1b, text="(随机范围)").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)
)
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))
# 鼠标配置
mouse_config_box = ttk.LabelFrame(debug_container, text="鼠标配置")
mouse_config_box.pack(fill=X, padx=10, pady=(0, 10))
mouse_r1 = ttk.Frame(mouse_config_box)
mouse_r1.pack(fill=X, padx=10, pady=(10, 8))
ttk.Label(mouse_r1, text="滑动速度(毫秒):").pack(side=LEFT)
ttk.Spinbox(
mouse_r1,
from_=100,
to=2000,
increment=50,
textvariable=swipe_duration_ms_var,
width=6,
).pack(side=LEFT)
ttk.Label(mouse_r1, text="(滑动持续时间,默认600ms,值越大滑动越慢)").pack(
side=LEFT, padx=(6, 0)
)
mouse_r2 = ttk.Frame(mouse_config_box)
mouse_r2.pack(fill=X, padx=10, pady=(0, 10))
ttk.Label(mouse_r2, text="上滑起始Y坐标:").pack(side=LEFT)
ttk.Spinbox(
mouse_r2,
from_=400,
to=2000,
increment=50,
textvariable=swipe_up_start_y_var,
width=6,
).pack(side=LEFT)
ttk.Label(mouse_r2, text="结束Y坐标:").pack(side=LEFT, padx=(10, 0))
ttk.Spinbox(
mouse_r2,
from_=200,
to=1800,
increment=50,
textvariable=swipe_up_end_y_var,
width=6,
).pack(side=LEFT)
ttk.Label(mouse_r2, text="(基准1080x2400,默认1200→600,距离600px)").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="详细阶段诊断日志", variable=stage_diag_verbose_var
).pack(side=LEFT)
ttk.Checkbutton(
diag_time_r2, text="启用OCR模式1(二值化)", variable=enable_ocr_mode1_var
).pack(side=LEFT, padx=(20, 0))
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)
)
pixel_r3 = ttk.Frame(pixel_detect_box)
pixel_r3.pack(fill=X, padx=10, pady=(0, 10))
ttk.Label(pixel_r3, text="购物红包背景红色占比阈值:").pack(side=LEFT)
ttk.Spinbox(
pixel_r3,
from_=0.0,
to=1.0,
increment=0.01,
textvariable=shopping_redpacket_red_ratio_threshold_var,
width=8,
).pack(side=LEFT)
ttk.Label(pixel_r3, text="(默认0.15,用于检测购物红包弹窗背景)").pack(
side=LEFT, padx=(6, 0)
)
# 标签页5:日志配置
logging_tab = ttk.Frame(left_notebook)
left_notebook.add(logging_tab, text="日志配置")
# 日志配置容器
logging_container = ttk.Frame(logging_tab)
logging_container.pack(fill=BOTH, expand=True, padx=10, pady=10)
# 日志格式设置
log_format_box = ttk.LabelFrame(logging_container, text="日志格式")
log_format_box.pack(fill=X, pady=(0, 10))
# 日志格式模式
log_format_r1 = ttk.Frame(log_format_box)
log_format_r1.pack(fill=X, padx=10, pady=(10, 6))
ttk.Label(log_format_r1, text="日志格式模式:").pack(side=LEFT)
ttk.Combobox(
log_format_r1,
values=["simple", "detailed"],
textvariable=logging_format_mode_var,
state="readonly",
width=12,
).pack(side=LEFT, padx=(0, 20))
ttk.Label(log_format_r1, text="(simple=简洁模式,detailed=详细模式用于debug)").pack(
side=LEFT, padx=(6, 0)
)
# 日志美化选项
log_format_r2 = ttk.Frame(log_format_box)
log_format_r2.pack(fill=X, padx=10, pady=(0, 10))
ttk.Checkbutton(
log_format_r2,
text="启用日志美化",
variable=logging_beautify_var,
).pack(side=LEFT)
ttk.Checkbutton(
log_format_r2,
text="启用颜色显示",
variable=logging_color_var,
).pack(side=LEFT, padx=(20, 0))
ttk.Checkbutton(
log_format_r2,
text="显示时间戳",
variable=logging_show_timestamps_var,
).pack(side=LEFT, padx=(20, 0))
# 日志详细程度设置
log_detail_box = ttk.LabelFrame(logging_container, text="日志详细程度")
log_detail_box.pack(fill=X, pady=(0, 10))
log_detail_r1 = ttk.Frame(log_detail_box)
log_detail_r1.pack(fill=X, padx=10, pady=(10, 6))
ttk.Label(log_detail_r1, text="调试日志详细程度:").pack(side=LEFT)
ttk.Combobox(
log_detail_r1,
values=["normal", "detailed", "minimal"],
textvariable=logging_debug_level_var,
state="readonly",
width=12,
).pack(side=LEFT, padx=(0, 20))
ttk.Label(log_detail_r1, text="错误日志详细程度:").pack(side=LEFT)
ttk.Combobox(
log_detail_r1,
values=["full", "basic", "minimal"],
textvariable=logging_error_level_var,
state="readonly",
width=12,
).pack(side=LEFT)
log_detail_r2 = ttk.Frame(log_detail_box)
log_detail_r2.pack(fill=X, padx=10, pady=(0, 10))
ttk.Label(log_detail_r2, text="行为日志格式:").pack(side=LEFT)
ttk.Combobox(
log_detail_r2,
values=["concise", "detailed", "minimal"],
textvariable=logging_action_format_var,
state="readonly",
width=12,
).pack(side=LEFT, padx=(0, 20))
ttk.Checkbutton(
log_detail_r2,
text="启用日志监控(超限告警/触发清理)",
variable=logging_enable_monitor_var,
).pack(side=LEFT, padx=(20, 0))
# 日志管理设置
log_manage_box = ttk.LabelFrame(logging_container, text="日志管理")
log_manage_box.pack(fill=X, pady=(0, 10))
log_manage_r1 = ttk.Frame(log_manage_box)
log_manage_r1.pack(fill=X, padx=10, pady=(10, 6))
ttk.Checkbutton(
log_manage_r1,
text="压缩旧日志",
variable=logging_compress_logs_var,
).pack(side=LEFT)
ttk.Label(log_manage_r1, text="保留天数:").pack(side=LEFT, padx=(20, 0))
ttk.Spinbox(
log_manage_r1,
from_=1,
to=365,
increment=1,
textvariable=logging_keep_days_var,
width=6,
).pack(side=LEFT, padx=(6, 16))
ttk.Label(log_manage_r1, text="总量上限(GB):").pack(side=LEFT)
ttk.Spinbox(
log_manage_r1,
from_=0.1,
to=100.0,
increment=0.1,
textvariable=logging_max_total_size_gb_var,
width=8,
).pack(side=LEFT, padx=(6, 16))
ttk.Label(log_manage_r1, text="压缩阈值(天):").pack(side=LEFT)
ttk.Spinbox(
log_manage_r1,
from_=0,
to=365,
increment=1,
textvariable=logging_compress_after_days_var,
width=6,
).pack(side=LEFT, padx=(6, 0))
log_manage_r2 = ttk.Frame(log_manage_box)
log_manage_r2.pack(fill=X, padx=10, pady=(0, 10))
ttk.Label(log_manage_r2, text="日志总大小警告阈值(MB):").pack(side=LEFT)
ttk.Spinbox(
log_manage_r2,
from_=50,
to=20000,
increment=50,
textvariable=logging_monitor_warning_mb_var,
width=8,
).pack(side=LEFT, padx=(6, 16))
ttk.Label(log_manage_r2, text="严重阈值(MB):").pack(side=LEFT)
ttk.Spinbox(
log_manage_r2,
from_=100,
to=100000,
increment=100,
textvariable=logging_monitor_critical_mb_var,
width=8,
).pack(side=LEFT, padx=(6, 0))
# 性能追踪设置
perf_box = ttk.LabelFrame(logging_container, text="性能追踪")
perf_box.pack(fill=X, pady=(0, 10))
perf_r1 = ttk.Frame(perf_box)
perf_r1.pack(fill=X, padx=10, pady=(10, 10))
ttk.Checkbutton(
perf_r1,
text="启用性能追踪",
variable=logging_performance_enabled_var,
).pack(side=LEFT)
ttk.Checkbutton(
perf_r1,
text="追踪函数调用",
variable=logging_track_functions_var,
).pack(side=LEFT, padx=(20, 0))
ttk.Checkbutton(
perf_r1,
text="流式后台截图(加速但可能导致并发读取)",
variable=streaming_enabled_var,
).pack(side=LEFT, padx=(20, 0))
# 界面主题选择
theme_box = ttk.LabelFrame(logging_container, text="界面设置")
theme_box.pack(fill=X, pady=(0, 10))
theme_r1 = ttk.Frame(theme_box)
theme_r1.pack(fill=X, padx=10, pady=(10, 10))
ttk.Label(theme_r1, text="界面主题:").pack(side=LEFT)
ttk.Combobox(
theme_r1,
values=["litera", "flatly", "journal", "minty", "cosmo", "darkly"],
textvariable=gui_theme_var,
state="readonly",
width=12,
).pack(side=LEFT, padx=(6, 0))
ttk.Label(theme_r1, text="(更改后请保存并重启以完全应用主题)").pack(
side=LEFT, padx=(12, 0)
)
# 保存配置按钮
save_config_frame = ttk.Frame(logging_container)
save_config_frame.pack(fill=X, pady=(10, 0))
ttk.Button(
save_config_frame,
text="保存日志配置",
command=save_logging_config,
).pack(side=LEFT, padx=(10, 0))
# 标签页6:调试参数
debug_tab = ttk.Frame(left_notebook)
# 标签页7:关键词
keywords_tab = ttk.Frame(left_notebook)
left_notebook.add(keywords_tab, text="关键词")
kw_box = ttk.LabelFrame(keywords_tab, text="关键词(每行一个,仅黑名单)")
kw_box.pack(fill=BOTH, expand=True, padx=10, pady=(10, 10))
ttk.Label(kw_box, text="不想要 contains_not_want(黑名单)").pack(
anchor="w", padx=10, pady=(10, 4)
)
not_want_text = ScrolledText(kw_box, height=8)
not_want_text.pack(fill=X, padx=10, pady=(0, 10))
def load_config_to_ui():
nonlocal cfg
cfg = read_config()
needswitch_var.set(bool(cfg.get("needswitch", True)))
infinite_loop_var.set(bool(cfg.get("infinite_loop_enabled", False)))
wait_minutes_var.set(int(cfg.get("wait_minutes", 5) or 5))
yg_enabled_var.set(bool(cfg.get("yanghao_enabled", True)))
yg_actions_enabled_var.set(bool(cfg.get("yanghao_enable_actions", True)))
yg_only_var.set(bool(cfg.get("yanghao_only", False)))
yg_recommend_duration_var.set(
int(cfg.get("yanghao_recommend_duration_seconds", 60) or 60)
)
yg_recommend_interval_var.set(
int(cfg.get("yanghao_recommend_interval_seconds", 0) or 0)
)
min_value_var.set(float(cfg.get("min_prize_value_yuan", 0) or 0))
min_participants_var.set(int(cfg.get("min_participants", 0) or 0))
max_participants_var.set(int(cfg.get("max_participants", 0) or 0))
skip_gt_seconds_var.set(
int(cfg.get("skip_if_countdown_gt_seconds", 900) or 900)
)
reset_after_swipes_enabled_var.set(
bool(cfg.get("reset_after_swipes_enabled", False))
)
reset_after_swipes_var.set(int(cfg.get("reset_after_swipes", 10) or 10))
reset_after_swipes_action_var.set(
str(cfg.get("reset_after_swipes_action", "swipe") or "swipe")
)
enable_back_on_misses_var.set(bool(cfg.get("enable_back_on_misses", True)))
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", 300) or 300)
)
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_fudai_poll_before_seconds_var.set(
float(cfg.get("high_value_fudai_poll_before_seconds", 10.0) or 10.0)
)
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))
)
high_value_room_revisit_min_interval_seconds_var.set(
int(cfg.get("high_value_room_revisit_min_interval_seconds", 300))
)
high_value_room_revisit_max_per_run_var.set(
int(cfg.get("high_value_room_revisit_max_per_run", 5))
)
high_value_room_revisit_min_prize_value_var.set(
float(cfg.get("high_value_room_revisit_min_prize_value", 0.0))
)
high_value_room_revisit_max_age_days_var.set(
int(cfg.get("high_value_room_revisit_max_age_days", 30))
)
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)
)
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)
try:
enable_back_on_misses_var.set(bool(cfg.get("enable_back_on_misses", True)))
except Exception:
enable_back_on_misses_var.set(True)
try:
reset_after_swipes_action_var.set(
str(cfg.get("reset_after_swipes_action", "swipe"))
)
except Exception:
reset_after_swipes_action_var.set("swipe")
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))
swipe_up_start_y_var.set(int(cfg.get("swipe_up_start_y", 1200) or 1200))
swipe_up_end_y_var.set(int(cfg.get("swipe_up_end_y", 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)
)
stage_diag_verbose_var.set(
bool(cfg.get("logging", {}).get("stage_diag_verbose", True))
)
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)
)
shopping_redpacket_red_ratio_threshold_var.set(
float(cfg.get("shopping_redpacket_red_ratio_threshold", 0.15) or 0.15)
)
# 粉丝团等待/点击延迟配置
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)
# 日志配置(load_config_to_ui 需要覆盖 UI 变量,避免“保存后再加载不生效”)
logging_config = cfg.get("logging", {})
if isinstance(logging_config, dict):
logging_beautify_var.set(bool(logging_config.get("beautify_output", True)))
logging_color_var.set(bool(logging_config.get("color_output", True)))
logging_show_timestamps_var.set(
bool(logging_config.get("show_timestamps", True))
)
logging_enable_monitor_var.set(
bool(logging_config.get("enable_monitor", True))
)
logging_keep_days_var.set(int(logging_config.get("keep_days", 30) or 30))
logging_compress_logs_var.set(
bool(logging_config.get("compress_logs", True))
)
logging_max_total_size_gb_var.set(
float(logging_config.get("max_total_size_gb", 10.0) or 10.0)
)
logging_compress_after_days_var.set(
int(logging_config.get("compress_after_days", 7) or 7)
)
logging_debug_level_var.set(
str(logging_config.get("debug_detail_level", "normal") or "normal")
)
logging_error_level_var.set(
str(logging_config.get("error_detail_level", "full") or "full")
)
logging_action_format_var.set(
str(logging_config.get("action_log_format", "concise") or "concise")
)
logging_format_mode_var.set(
str(logging_config.get("log_format_mode", "simple") or "simple")
)
perf_cfg = logging_config.get("performance_tracking", {})
if isinstance(perf_cfg, dict):
logging_performance_enabled_var.set(bool(perf_cfg.get("enabled", True)))
logging_track_functions_var.set(
bool(perf_cfg.get("track_function_calls", True))
)
logging_monitor_warning_mb_var.set(
float(logging_config.get("monitor_warning_mb", 500.0) or 500.0)
)
logging_monitor_critical_mb_var.set(
float(logging_config.get("monitor_critical_mb", 2000.0) or 2000.0)
)
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_dwell_on_action_min_var.set(
float(cfg.get("yanghao_dwell_on_action_min_seconds", 5) or 5)
)
yg_dwell_on_action_max_var.set(
float(cfg.get("yanghao_dwell_on_action_max_seconds", 30) or 30)
)
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 300
)
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_fudai_poll_before_seconds"] = float(
high_value_fudai_poll_before_seconds_var.get() or 10.0
)
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["high_value_room_revisit_min_interval_seconds"] = int(
high_value_room_revisit_min_interval_seconds_var.get()
)
cfg2["high_value_room_revisit_max_per_run"] = int(
high_value_room_revisit_max_per_run_var.get()
)
cfg2["high_value_room_revisit_min_prize_value"] = float(
high_value_room_revisit_min_prize_value_var.get()
)
cfg2["high_value_room_revisit_max_age_days"] = int(
high_value_room_revisit_max_age_days_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_back_verify_wait_seconds"] = float(
reservation_back_verify_wait_seconds_var.get() or 5.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["enable_back_on_misses"] = bool(enable_back_on_misses_var.get())
cfg2["reset_after_swipes_action"] = str(
reset_after_swipes_action_var.get() or "swipe"
)
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["swipe_up_start_y"] = int(swipe_up_start_y_var.get() or 1200)
cfg2["swipe_up_end_y"] = int(swipe_up_end_y_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["shopping_redpacket_red_ratio_threshold"] = float(
shopping_redpacket_red_ratio_threshold_var.get() or 0.15
)
# 粉丝团等待/点击延迟配置
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"]["enable_monitor"] = bool(logging_enable_monitor_var.get())
cfg2["logging"]["keep_days"] = int(logging_keep_days_var.get() or 30)
cfg2["logging"]["compress_logs"] = bool(logging_compress_logs_var.get())
cfg2["logging"]["max_total_size_gb"] = float(
logging_max_total_size_gb_var.get() or 10.0
)
cfg2["logging"]["compress_after_days"] = int(
logging_compress_after_days_var.get() or 7
)
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"
)
cfg2["logging"]["log_format_mode"] = str(
logging_format_mode_var.get() or "simple"
)
cfg2["logging"]["stage_diag_verbose"] = bool(stage_diag_verbose_var.get())
cfg2["logging"]["monitor_warning_mb"] = float(
logging_monitor_warning_mb_var.get() or 500.0
)
cfg2["logging"]["monitor_critical_mb"] = float(
logging_monitor_critical_mb_var.get() or 2000.0
)
# 性能追踪配置
if "performance_tracking" not in cfg2["logging"] or not isinstance(
cfg2["logging"]["performance_tracking"], dict
):
cfg2["logging"]["performance_tracking"] = {}
cfg2["logging"]["performance_tracking"]["enabled"] = bool(
logging_performance_enabled_var.get()
)
cfg2["logging"]["performance_tracking"]["track_function_calls"] = bool(
logging_track_functions_var.get()
)
cfg2["yanghao_enabled"] = bool(yg_enabled_var.get())
cfg2["yanghao_enable_actions"] = bool(yg_actions_enabled_var.get())
cfg2["yanghao_only"] = bool(yg_only_var.get())
cfg2["yanghao_recommend_duration_seconds"] = int(
yg_recommend_duration_var.get() or 60
)
cfg2["yanghao_recommend_interval_seconds"] = int(
yg_recommend_interval_var.get() or 0
)
cfg2["yanghao_like_prob"] = float(yg_like_prob_var.get() or 0.0)
cfg2["yanghao_fav_prob"] = float(yg_fav_prob_var.get() or 0.0)
cfg2["yanghao_comment_prob"] = float(yg_comment_prob_var.get() or 0.0)
cfg2["yanghao_dwell_on_action_min_seconds"] = float(
yg_dwell_on_action_min_var.get() or 5
)
cfg2["yanghao_dwell_on_action_max_seconds"] = float(
yg_dwell_on_action_max_var.get() or 30
)
cfg2["yanghao_icon_roi_size"] = int(yg_icon_roi_size_var.get() or 240)
cfg2["yanghao_icon_match_threshold"] = float(
yg_icon_match_threshold_var.get() or 0.72
)
cfg2["yanghao_step_screenshot"] = bool(yg_step_screenshot_var.get())
cfg2["yanghao_like_roi_offset_x"] = int(yg_like_roi_offset_x_var.get() or 0)
cfg2["yanghao_like_roi_offset_y"] = int(yg_like_roi_offset_y_var.get() or 0)
cfg2["yanghao_fav_roi_offset_x"] = int(yg_fav_roi_offset_x_var.get() or 0)
cfg2["yanghao_fav_roi_offset_y"] = int(yg_fav_roi_offset_y_var.get() or 0)
cfg2["yanghao_like_icon_x"] = int(yg_like_icon_x_var.get() or 0)
cfg2["yanghao_like_icon_y"] = int(yg_like_icon_y_var.get() or 0)
cfg2["yanghao_fav_icon_x"] = int(yg_fav_icon_x_var.get() or 0)
cfg2["yanghao_fav_icon_y"] = int(yg_fav_icon_y_var.get() or 0)
cfg2["yanghao_like_template_path"] = str(
yg_like_template_path_var.get() or "assets/like.png"
)
cfg2["yanghao_fav_template_path"] = str(
yg_fav_template_path_var.get() or "assets/fav.png"
)
cfg2["yanghao_after_dwell_swipe_direction"] = str(
yg_after_dwell_direction_var.get() or "up"
)
cfg2["yanghao_after_dwell_swipe_distance_px"] = int(
yg_after_dwell_distance_var.get() or 900
)
cfg2["yanghao_comment_btn_x"] = int(yg_comment_btn_x_var.get() or 0)
cfg2["yanghao_comment_btn_y"] = int(yg_comment_btn_y_var.get() or 0)
cfg2["yanghao_comment_input_x"] = int(yg_comment_input_x_var.get() or 0)
cfg2["yanghao_comment_input_y"] = int(yg_comment_input_y_var.get() or 0)
cfg2["yanghao_comment_send_x"] = int(yg_comment_send_x_var.get() or 0)
cfg2["yanghao_comment_send_y"] = int(yg_comment_send_y_var.get() or 0)
cfg2["yanghao_comment_close_x"] = int(yg_comment_close_x_var.get() or 0)
cfg2["yanghao_comment_close_y"] = int(yg_comment_close_y_var.get() or 0)
cfg2["yanghao_comment_texts"] = yg_comment_text_lines
cfg2["yanghao_like_keywords"] = yg_like_kw_lines
cfg2["yanghao_fav_keywords"] = yg_fav_kw_lines
# 流式后台截图配置
cfg2["enable_streaming_screenshot"] = bool(streaming_enabled_var.get())
# GUI 配置
if "gui" not in cfg2 or not isinstance(cfg2["gui"], dict):
cfg2["gui"] = {}
cfg2["gui"]["theme"] = str(gui_theme_var.get() or "litera")
write_config(cfg2)
on_line("[配置] 已保存到 config.json")
# 如果用户关闭了流式后台截图,尝试停止正在运行的服务实例以立即生效
try:
from operations.screenshot_service import ScreenshotService
if not bool(cfg2.get("enable_streaming_screenshot", True)):
try:
ScreenshotService.get_instance().stop()
on_line("[截图服务] 已停止后台流式截图(配置更新)")
except Exception:
on_line("[截图服务] 停止后台截图服务失败(请重启程序以确保生效)")
except Exception:
# ignore if service module not available
pass
load_config_to_ui()
# 顶部常驻按钮区域(与设备选择同一行,不随左侧滚动)
top_btns = ttk.Frame(top)
top_btns.pack(side=RIGHT, padx=(20, 0))
ttk.Button(top_btns, text="保存配置", command=save_ui_to_config).pack(
side=LEFT, padx=(0, 8)
)
# 截图+OCR 按钮也放在顶部,方便随时使用
# 具体回调在后文定义,这里先占位,通过 lambda 延迟绑定
screenshot_button_var = {"command": None}
def _bind_screenshot_button(btn):
# 在 do_screenshot 定义后调用,将真正的 command 绑定到按钮
screenshot_button_var["button"] = btn
screenshot_btn = ttk.Button(top_btns, text="截图+OCR")
screenshot_btn.pack(side=LEFT, padx=(0, 8))
_bind_screenshot_button(screenshot_btn)
# OCR区域配置:定义所有需要识别的区域(坐标基于1080x2400基准)
OCR_REGIONS = [
# (区域名称, (x1, y1, x2, y2), 描述)
("福袋内容", (389, 1273, 1000, 1534), "福袋内容详情"),
("福袋倒计时", (390, 1470, 980, 1580), "福袋倒计时"),
("福袋价值", (390, 1440, 1000, 1580), "奖品价值/价格"),
("抽奖结果", (380, 660, 720, 755), "抽奖结果弹窗"),
("推荐页标签栏", (400, 140, 900, 200), "推荐/关注/直播标签"),
("推荐页标签栏快速检测", (400, 140, 900, 200), "推荐页快速检测"),
("参与按钮", (306, 2030, 780, 2110), "参与福袋抽奖按钮"),
("无奖励确认", (340, 1195, 740, 1355), "无奖励确认弹窗"),
("奖励通知确认", (370, 1350, 680, 1440), "奖励通知确认"),
("订单确认", (370, 120, 700, 220), "订单确认页面"),
("关注列表标签", (658, 147, 765, 194), "关注列表标签"),
("直播列表标签", (400, 140, 900, 200), "直播列表标签"),
("直播广场", (400, 140, 900, 200), "直播广场标题"),
("直播间标题_中", (400, 140, 900, 200), "直播间标题中部"),
("诊断优惠券标题", (60, 1260, 1020, 1480), "优惠券弹窗标题"),
("诊断优惠券按钮", (400, 1600, 680, 1700), "优惠券按钮"),
("诊断购物红包", (400, 1400, 900, 1600), "购物红包弹窗"),
]
# 截图按钮
def do_screenshot():
device_id = device_var.get().strip()
if not device_id:
on_line("[截图] 请先选择设备")
return
# 在后台线程中执行截图和OCR识别,避免阻塞GUI
def screenshot_thread():
try:
from Underlying_Operations import underlying_operations
# 使用模块级别导入的 Image 与 os,避免重复导入导致 Pylance 警告
# 使用 root.after 在主线程中更新日志
def log_msg(msg: str) -> Callable[[], None]:
def wrapper() -> None:
on_line(msg)
return wrapper
root.after(0, log_msg("[截图] 正在截图...")) # type: ignore[arg-type]
ops = underlying_operations()
result = ops.get_screenshot(device_id, use_service=False)
if not result:
root.after(0, log_msg("[截图] 截图失败")) # type: ignore[arg-type]
return
root.after(0, log_msg("[截图] 截图成功,已保存到 pic/screenshot.png")) # type: ignore[arg-type]
# 读取截图以获取实际尺寸
try:
from path_config import get_screenshot_path
screenshot_path = get_screenshot_path()
except Exception:
# 回退到旧路径(向后兼容)
import path_config
screenshot_path = path_config.get_screenshot_path()
if not os.path.exists(screenshot_path):
root.after(0, log_msg("[OCR] 截图文件不存在")) # type: ignore[arg-type]
return
try:
img = Image.open(screenshot_path)
img.load() # Force load to catch truncated files early
img_width, img_height = img.size
# 计算缩放比例(基于1080x2400基准)
scale_x = img_width / 1080.0
scale_y = img_height / 2400.0
except (OSError, IOError, SyntaxError) as e:
# Handle truncated image files
root.after(0, log_msg(f"图片文件损坏或截断: {e}")) # type: ignore[arg-type]
return
except Exception as e:
root.after(0, log_msg(f"[OCR] 读取截图失败: {e}")) # type: ignore[arg-type]
return
# 获取Y偏移
y_offset = int(y_var.get() or 0)
# 执行所有OCR区域的识别
ocr_results = []
total_regions = len(OCR_REGIONS)
root.after(0, log_msg(f"[OCR] 开始识别 {total_regions} 个区域...")) # type: ignore[arg-type]
for idx, (region_name, (x1, y1, x2, y2), desc) in enumerate(
OCR_REGIONS, 1
):
try:
# 缩放坐标到实际截图尺寸
actual_x1 = int(x1 * scale_x)
actual_y1 = int(y1 * scale_y) + y_offset
actual_x2 = int(x2 * scale_x)
actual_y2 = int(y2 * scale_y) + y_offset
# 确保坐标在图片范围内
actual_x1 = max(0, min(actual_x1, img_width))
actual_y1 = max(0, min(actual_y1, img_height))
actual_x2 = max(0, min(actual_x2, img_width))
actual_y2 = max(0, min(actual_y2, img_height))
if actual_x1 >= actual_x2 or actual_y1 >= actual_y2:
root.after(0, log_msg(f"[OCR] {region_name}: 坐标无效,跳过")) # type: ignore[arg-type]
continue
# 截取区域
cut_result = ops.cut_pic(
(actual_x1, actual_y1),
(actual_x2, actual_y2),
"",
region_name,
)
if not cut_result:
root.after(0, log_msg(f"[OCR] {region_name}: 截图失败")) # type: ignore[arg-type]
ocr_results.append((region_name, desc, "", "截图失败"))
continue
# OCR识别(先尝试模式0,如果为空再尝试模式1)
text_result = ""
ocr_mode = 0
for mode in [0, 1]:
try:
text = str(
ops.analyse_pic_word(region_name, mode) or ""
).strip()
if text:
text_result = text
ocr_mode = mode
break
except Exception:
continue
ocr_results.append(
(region_name, desc, text_result, f"模式{ocr_mode}")
)
status_msg = f"[OCR] ({idx}/{total_regions}) {region_name}: {text_result[:50] if text_result else '(空)'}"
root.after(0, log_msg(status_msg)) # type: ignore[arg-type]
except Exception as e:
error_msg = f"[OCR] {region_name}: 异常 - {e}"
root.after(0, log_msg(error_msg)) # type: ignore[arg-type]
ocr_results.append((region_name, desc, "", f"异常: {e}"))
# 更新OCR结果标签页
def update_ocr_wrapper() -> None:
update_ocr_results(ocr_results)
root.after(0, update_ocr_wrapper) # type: ignore[arg-type]
root.after(0, log_msg(f"[OCR] 完成!共识别 {len(ocr_results)} 个区域")) # type: ignore[arg-type]
# 刷新截图预览(如果当前显示的是 screenshot.png)
def refresh_if_screenshot() -> None:
if image_var.get() == "screenshot.png":
refresh_preview()
root.after(0, refresh_if_screenshot) # type: ignore[arg-type]
except Exception as e:
import traceback
error_detail = traceback.format_exc()
root.after(0, log_msg(f"[截图] 截图异常: {e}\n{error_detail}")) # type: ignore[arg-type]
thread = threading.Thread(target=screenshot_thread, daemon=True)
thread.start()
# 将顶部“截图+OCR”按钮的回调绑定到 do_screenshot
try:
btn = screenshot_button_var.get("button")
if btn is not None:
btn.configure(command=do_screenshot)
except Exception:
pass
# 右侧:操作按钮区域(先创建,放在底部)
actions = ttk.Frame(right)
# 右侧:Notebook(日志 / 截图预览 / 统计信息 / 预约队列 / 高价值房间)
notebook = ttk.Notebook(right)
# 实时状态工具栏(固定在 Notebook 上方,始终可见)
show_actions_var = tk.BooleanVar(value=True)
show_screenshot_var = tk.BooleanVar(value=False)
auto_scroll_var = tk.BooleanVar(value=True)
realtime_tools = ttk.Frame(right)
realtime_tools.pack(fill=X, padx=8, pady=(4, 0))
ttk.Checkbutton(realtime_tools, text="显示动作流", variable=show_actions_var).pack(
side=LEFT, padx=(0, 8)
)
ttk.Checkbutton(realtime_tools, text="显示截图", variable=show_screenshot_var).pack(
side=LEFT, padx=(0, 8)
)
ttk.Checkbutton(realtime_tools, text="自动滚动", variable=auto_scroll_var).pack(
side=LEFT, padx=(0, 8)
)
# forward-declare handler to satisfy linters; real function defined later
_open_realtime_viewer_impl = None
realtime_view_btn = ttk.Button(
realtime_tools,
text="实时查看",
width=10,
command=lambda: (
_open_realtime_viewer_impl()
if callable(_open_realtime_viewer_impl)
else None
),
)
realtime_view_btn.pack(side=LEFT, padx=(8, 0))
log_tab = ttk.Frame(notebook)
preview_tab = ttk.Frame(notebook)
stats_tab = ttk.Frame(notebook)
reservation_tab = ttk.Frame(notebook)
high_value_tab = ttk.Frame(notebook)
actions_log_tab = ttk.Frame(notebook)
realtime_tab = ttk.Frame(notebook)
ocr_results_tab = ttk.Frame(notebook)
win_record_tab = ttk.Frame(notebook)
notebook.add(log_tab, text="运行日志")
notebook.add(preview_tab, text="截图预览")
notebook.add(stats_tab, text="统计信息")
notebook.add(reservation_tab, text="预约队列")
notebook.add(high_value_tab, text="高价值房间")
notebook.add(actions_log_tab, text="行为日志")
notebook.add(realtime_tab, text="实时状态")
notebook.add(ocr_results_tab, text="OCR结果")
notebook.add(win_record_tab, text="中奖记录")
# 使用模块化组件创建映射表并加入 Notebook
mapping_tab = create_mapping_tab(root, notebook, cfg)
notebook.add(mapping_tab, text="映射表")
# 日志区
log_box = ttk.Frame(log_tab)
log_box.pack(fill=BOTH, expand=True)
# ========== 实时状态 Tab(显示最近动作 + 耗时) ==========
try:
realtime_frame = ttk.Frame(realtime_tab)
realtime_frame.pack(fill=BOTH, expand=True, padx=8, pady=8)
# 截图预览区域(根据选项显示/隐藏)
image_label = ttk.Label(realtime_frame)
image_label.pack(fill=X)
realtime_text = ScrolledText(realtime_frame, height=14)
realtime_text.pack(fill=BOTH, expand=True)
realtime_text.configure(state="disabled")
# re 已在模块顶部导入,避免重复导入
realtime_after_id = None
def tail_read_file(path: str, max_bytes: int = 64 * 1024) -> list[str]:
"""从文件尾部读取最多 max_bytes,并返回按行分割的字符串列表(按文件顺序)。"""
try:
if not os.path.exists(path):
return []
with open(path, "rb") as f:
f.seek(0, os.SEEK_END)
file_size = f.tell()
seek_from = max(0, file_size - max_bytes)
f.seek(seek_from)
data = f.read()
text = data.decode(errors="ignore")
# splitlines 保留不含尾部换行的处理
return text.splitlines()
except Exception:
return []
def parse_action_duration(line: str) -> tuple[str, str] | None:
"""从一行日志提取 (action, duration),未找到返回 None。"""
if "耗时" not in line:
return None
# 尝试提取耗时数字
m = re.search(
r"耗时[:=]?\s*([0-9]+(?:[.\u00B7\uFF0E\uFF61·.。][0-9]+)?)\s*s", line
)
dur = None
if m:
dur = m.group(1) + "s"
else:
m2 = re.search(
r"([0-9]+(?:[.\u00B7\uFF0E\uFF61·.。][0-9]+)?)\s*s", line
)
if m2:
dur = m2.group(1) + "s"
if not dur:
return None
# 动作名取耗时之前的文本片段,最多保留 60 字符
idx = line.find("耗时")
action = line[:idx].strip()
if not action:
# 兜底:取整行前 60 字符
action = line.strip()[:60]
if len(action) > 60:
action = action[:57] + "..."
return (action, dur)
def refresh_realtime_tab():
nonlocal realtime_after_id
cfg = read_config()
gui_cfg = cfg.get("gui", {}).get("realtime_status", {})
refresh_ms = int(gui_cfg.get("refresh_interval_ms", 1000))
tail_items = int(gui_cfg.get("tail_items", 50))
path = os.path.join(get_logs_dir(), "actions.log")
lines = tail_read_file(path)
parsed: list[tuple[str, str]] = []
# 从文件末尾向前解析,保持原始顺序输出最近项
for line in reversed(lines):
try:
out = parse_action_duration(line)
if out:
parsed.append(out)
if len(parsed) >= tail_items:
break
except Exception:
continue
parsed = list(reversed(parsed))
# 更新截图(若选中)
if show_screenshot_var.get():
try:
try:
from path_config import get_screenshot_path
screenshot_path = get_screenshot_path()
except Exception:
import path_config
screenshot_path = path_config.get_screenshot_path()
if os.path.exists(screenshot_path):
img = Image.open(screenshot_path)
# 缩放以适应宽度(保持纵横比),最大宽度 420
max_w = 420
w, h = img.size
if w > max_w:
nw = max_w
nh = int(h * (nw / w))
img = img.resize((nw, nh), Image.LANCZOS)
tk_img = ImageTk.PhotoImage(img)
image_label.configure(image=tk_img)
image_label.image = tk_img
image_label.pack(fill=X)
else:
image_label.configure(image="")
image_label.image = None
image_label.pack_forget()
except Exception:
image_label.configure(image="")
image_label.image = None
image_label.pack_forget()
else:
image_label.configure(image="")
image_label.image = None
image_label.pack_forget()
# 更新动作流文本(若选中)
if show_actions_var.get():
realtime_text.configure(state="normal")
realtime_text.delete("1.0", "end")
if not parsed:
realtime_text.insert("1.0", "暂无动作日志(仅显示包含“耗时”的行)")
else:
for action, dur in parsed:
realtime_text.insert("end", f"{action} {dur}\n")
# 自动滚动
if auto_scroll_var.get():
try:
realtime_text.see("end")
except Exception:
try:
realtime_text.yview_moveto(1.0)
except Exception:
pass
realtime_text.configure(state="disabled")
else:
# 隐藏文本内容但保留控件
realtime_text.configure(state="normal")
realtime_text.delete("1.0", "end")
realtime_text.configure(state="disabled")
# 安排下一次刷新
try:
realtime_after_id = root.after(refresh_ms, refresh_realtime_tab)
except Exception:
realtime_after_id = None
# 启动刷新(仅在 Tab 被创建时启动)
try:
refresh_realtime_tab()
except Exception:
pass
except Exception:
pass
# --------- 实时查看弹窗(紧凑视图) ---------
def _open_realtime_viewer_impl():
try:
# 如果已打开则直接聚焦
if (
hasattr(_open_realtime_viewer_impl, "_win")
and _open_realtime_viewer_impl._win
):
try:
_open_realtime_viewer_impl._win.lift()
except Exception:
pass
return
win = tk.Toplevel(root)
win.title("实时查看 - 截图与最简动作流")
win.geometry("520x520")
_open_realtime_viewer_impl._win = win
# 图片与列表
img_lbl = ttk.Label(win)
img_lbl.pack(fill=X, pady=(6, 4))
list_frame = ttk.Frame(win)
list_frame.pack(fill=BOTH, expand=True, padx=6, pady=6)
listbox = tk.Listbox(list_frame, height=12)
listbox.pack(side=LEFT, fill=BOTH, expand=True)
scrollbar = ttk.Scrollbar(
list_frame, orient=tk.VERTICAL, command=listbox.yview
)
scrollbar.pack(side=RIGHT, fill=Y)
listbox.configure(yscrollcommand=scrollbar.set)
stop_flag = {"stop": False}
def close_win():
stop_flag["stop"] = True
try:
win.destroy()
except Exception:
pass
_open_realtime_viewer_impl._win = None
win.protocol("WM_DELETE_WINDOW", close_win)
# use module-level `re`
def tail_read(path: str, max_bytes: int = 64 * 1024) -> list[str]:
try:
if not os.path.exists(path):
return []
with open(path, "rb") as f:
f.seek(0, os.SEEK_END)
sz = f.tell()
f.seek(max(0, sz - max_bytes))
return f.read().decode(errors="ignore").splitlines()
except Exception:
return []
def parse_minimal(line: str) -> tuple[str, str] | None:
if "耗时" not in line:
return None
m = re.search(r"耗时[:=]?\s*([0-9]+(?:\.[0-9]+)?)\s*s", line)
dur = None
if m:
dur = m.group(1) + "s"
else:
m2 = re.search(r"([0-9]+(?:\.[0-9]+)?)\s*s", line)
if m2:
dur = m2.group(1) + "s"
if not dur:
return None
idx = line.find("耗时")
action = line[:idx].strip()
if not action:
action = line.strip()[:80]
if len(action) > 80:
action = action[:77] + "..."
return (action, dur)
def update_loop():
if stop_flag["stop"]:
return
# update image
try:
try:
from path_config import get_screenshot_path
screenshot_path = get_screenshot_path()
except Exception:
import path_config
screenshot_path = path_config.get_screenshot_path()
if os.path.exists(screenshot_path):
img = Image.open(screenshot_path)
max_w = 480
w, h = img.size
if w > max_w:
nw = max_w
nh = int(h * (nw / w))
img = img.resize((nw, nh), Image.LANCZOS)
tkimg = ImageTk.PhotoImage(img)
img_lbl.configure(image=tkimg)
img_lbl.image = tkimg
else:
img_lbl.configure(image=None)
img_lbl.image = None
except Exception:
img_lbl.configure(image=None)
img_lbl.image = None
# update minimal list
try:
path = os.path.join(get_logs_dir(), "actions.log")
lines = tail_read(path, max_bytes=64 * 1024)
items: list[str] = []
for line in reversed(lines):
out = parse_minimal(line)
if out:
items.append(f"{out[0]} {out[1]}")
if len(items) >= 80:
break
items = list(reversed(items))
listbox.delete(0, tk.END)
if not items:
listbox.insert(tk.END, "暂无动作(仅显示包含 耗时 的行)")
else:
for it in items:
listbox.insert(tk.END, it)
# 自动滚动到末尾
try:
listbox.yview_moveto(1.0)
except Exception:
pass
except Exception:
try:
listbox.delete(0, tk.END)
listbox.insert(tk.END, "更新失败")
except Exception:
pass
# schedule next
try:
win.after(1000, update_loop)
except Exception:
return
# start
update_loop()
except Exception:
return
# 搜索工具栏
log_search_frame = ttk.Frame(log_box)
log_search_frame.pack(fill=X, padx=10, pady=(10, 5))
# 关键字筛选(与行为日志一致)
log_filter_var = tk.StringVar(value="")
ttk.Label(log_search_frame, text="筛选:").pack(side=LEFT)
ttk.Entry(log_search_frame, textvariable=log_filter_var, width=16).pack(
side=LEFT, padx=(0, 8)
)
log_search_var = tk.StringVar(value="")
log_search_entry = ttk.Entry(
log_search_frame, textvariable=log_search_var, width=20
)
def refresh_run_log():
"""从内存中读取最近若干运行日志并在界面中刷新(行为上与行为日志一致)"""
try:
tail_n = 1000
# 读取 runner 内存日志(线程安全)
with runner._lock:
total = len(runner._log)
cand = runner._log[-tail_n:] if tail_n > 0 else runner._log[:]
# 应用筛选关键词
kw = log_filter_var.get().strip()
if kw:
cand = [ln for ln in cand if kw in (ln or "")]
# 保存滚动位置
try:
scroll_pos = log_text.yview()[0]
except Exception:
scroll_pos = 1.0
log_text.delete("1.0", "end")
if cand:
try:
current_theme = str(gui_theme_var.get() or "litera")
except Exception:
current_theme = "litera"
for i, line in enumerate(cand):
start_pos = log_text.index("end-1c")
if i > 0:
log_text.insert("end", "\n")
log_text.insert("end", line)
end_pos = log_text.index("end")
try:
op_type = get_operation_type(line)
if op_type:
apply_operation_color(
log_text, start_pos, end_pos, line, current_theme
)
except Exception:
pass
else:
log_text.insert("1.0", "暂无匹配的运行日志")
try:
log_text.yview_moveto(scroll_pos)
except Exception:
pass
except Exception as e:
try:
log_text.delete("1.0", "end")
log_text.insert("1.0", f"刷新运行日志失败:{e}")
except Exception:
pass
log_search_matches = [] # 存储所有匹配的位置
log_current_match_index = -1 # 当前匹配的索引
def _generic_search_widget(
widget, search_var, matches_list, current_index, direction=1
):
"""通用的文本控件搜索函数:在 widget 中根据 search_var 搜索并高亮。
- widget: 文本控件(ScrolledText)
- search_var: tk.StringVar (包含搜索词)
- matches_list: 可变列表,用来保存匹配区间 (start_index, end_index)
- current_index: 当前匹配的索引(整数),返回更新后的索引
- direction: 1 为下一个,-1 为上一个
"""
search_text = search_var.get().strip()
if not search_text:
try:
widget.tag_remove("search_highlight", "1.0", "end")
widget.tag_remove("search_current", "1.0", "end")
except Exception:
pass
matches_list.clear()
return -1
content = widget.get("1.0", "end-1c")
if not content:
return -1
try:
widget.tag_remove("search_highlight", "1.0", "end")
widget.tag_remove("search_current", "1.0", "end")
except Exception:
pass
try:
widget.tag_config("search_highlight", background="yellow")
widget.tag_config("search_current", background="orange")
except Exception:
pass
matches_list.clear()
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)}"
matches_list.append((start_index, end_index))
start_pos = pos + 1
if not matches_list:
return -1
for s, e in matches_list:
try:
widget.tag_add("search_highlight", s, e)
except Exception:
pass
if direction == 1:
current_index = (current_index + 1) % len(matches_list)
else:
current_index = (current_index - 1) % len(matches_list)
try:
s, e = matches_list[current_index]
widget.tag_add("search_current", s, e)
widget.see(s)
widget.mark_set("insert", s)
except Exception:
pass
return current_index
def search_in_log_text(direction=1):
"""在运行日志中搜索文本(调用通用搜索实现)"""
nonlocal log_search_matches, log_current_match_index
log_current_match_index = _generic_search_widget(
log_text,
log_search_var,
log_search_matches,
log_current_match_index,
direction,
)
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=refresh_run_log).pack(
side=LEFT, padx=(0, 8)
)
ttk.Separator(log_search_frame, orient="vertical").pack(
side=LEFT, fill=Y, padx=5, pady=3
)
ttk.Label(log_search_frame, text="搜索:").pack(side=LEFT)
# 把搜索输入框放在分隔符后
log_search_entry.pack(side=LEFT, padx=(0, 5))
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), str(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()
),
high_value_room_revisit_min_interval_seconds=int(
high_value_room_revisit_min_interval_seconds_var.get()
),
high_value_room_revisit_max_per_run=int(
high_value_room_revisit_max_per_run_var.get()
),
high_value_room_revisit_min_prize_value=float(
high_value_room_revisit_min_prize_value_var.get()
),
high_value_room_revisit_max_age_days=int(
high_value_room_revisit_max_age_days_var.get()
),
high_value_fudai_poll_before_seconds=float(
high_value_fudai_poll_before_seconds_var.get() or 10.0
),
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
),
fudai_find_max_attempts=int(fudai_find_max_attempts_var.get() or 5),
enable_ocr_mode1=bool(enable_ocr_mode1_var.get()),
fudai_template_match_enabled=bool(fudai_template_match_enabled_var.get()),
fudai_template_match_threshold=float(
fudai_template_match_threshold_var.get() or 0.7
),
# 只养号模式与养号时长
yanghao_only=bool(yg_only_var.get()),
yanghao_seconds=int(yg_recommend_duration_var.get() or 0),
enable_back_on_misses=bool(enable_back_on_misses_var.get()),
)
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:
kw = log_filter_var.get().strip()
if kw and kw not in line:
continue
except Exception:
pass
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("运行时长: -")
last_log_ts = stats.get("last_log_ts")
if last_log_ts:
dt = datetime.fromtimestamp(last_log_ts)
lines.append("最近日志时间: " + dt.strftime("%Y-%m-%d %H:%M:%S"))
else:
lines.append("最近日志时间: -")
exit_code = stats.get("exit_code")
lines.append(f"退出码: {exit_code if exit_code is not None else '-'}")
lines.append("")
# 计数器统计
counters = stats.get("counters", {})
# 快速汇总(关键指标)
fudai_seen = counters.get("fudai_seen", 0)
fudai_seen_unique = counters.get("fudai_seen_unique", 0)
fudai_attend_ok = counters.get("fudai_attend_ok", 0)
fudai_attend_ok_unique = counters.get("fudai_attend_ok_unique", 0)
fudai_result_win = counters.get("fudai_result_win", 0)
fudai_order_success = counters.get("fudai_order_success", 0)
if (
fudai_seen_unique > 0
or fudai_attend_ok_unique > 0
or fudai_result_win > 0
):
lines.append("=" * 60)
lines.append("快速汇总")
lines.append("=" * 60)
lines.append(f"识别福袋: {fudai_seen_unique} 个")
lines.append(f"参与成功: {fudai_attend_ok_unique} 次")
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_unique / hours:.1f} 次参与/小时"
)
lines.append("")
# 核心统计(总是显示,即使数据为0)
lines.append("=" * 60)
lines.append("核心统计")
lines.append("=" * 60)
# 福袋相关核心指标(重新获取,避免重复定义)
fudai_open_detail = counters.get("fudai_open_detail", 0)
fudai_open_detail_unique = counters.get("fudai_open_detail_unique", 0)
fudai_click_attend = counters.get("fudai_click_attend", 0)
fudai_click_attend_unique = counters.get("fudai_click_attend_unique", 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_unique}")
lines.append(f"打开详情: {fudai_open_detail_unique}")
if fudai_seen_unique > 0:
open_rate = (fudai_open_detail_unique / fudai_seen_unique) * 100
lines.append(f" 打开成功率: {open_rate:.1f}%")
lines.append(f"点击参与: {fudai_click_attend_unique}")
if fudai_open_detail_unique > 0:
click_rate = (
fudai_click_attend_unique / fudai_open_detail_unique
) * 100
lines.append(f" 点击率: {click_rate:.1f}%")
lines.append(f"参与成功: {fudai_attend_ok_unique}")
lines.append(f"参与失败: {fudai_attend_fail}")
# 参与成功率应该基于点击参与次数来计算
# 因为参与成功可能包括"检测到已参与"的情况(没有点击)
if fudai_click_attend_unique > 0:
# 通过点击参与成功的次数(不超过点击参与次数)
click_attend_success = min(
fudai_attend_ok_unique, fudai_click_attend_unique
)
success_rate = (click_attend_success / fudai_click_attend_unique) * 100
lines.append(f" 参与成功率: {success_rate:.1f}%")
# 如果参与成功 > 点击参与,说明有检测到已参与的情况
if fudai_attend_ok_unique > fudai_click_attend_unique:
detected_already_attended = (
fudai_attend_ok_unique - fudai_click_attend_unique
)
lines.append(
f" (其中 {detected_already_attended} 次为检测到已参与状态)"
)
elif fudai_attend_ok_unique > 0 or fudai_attend_fail > 0:
# 如果没有点击参与但有参与结果,使用原来的计算方式
total_attend = fudai_attend_ok_unique + fudai_attend_fail
if total_attend > 0:
success_rate = (fudai_attend_ok_unique / 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_unique > 0 and total_results < fudai_attend_ok_unique:
pending_results = fudai_attend_ok_unique - 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_unique > 0:
lines.append(
f" 识别福袋: {fudai_seen_unique / hours:.1f} 个/小时"
)
if fudai_attend_ok_unique > 0:
lines.append(
f" 参与成功: {fudai_attend_ok_unique / 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_unique > 0:
skip_rate = (skip_total / fudai_seen_unique) * 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_unique > len(prize_values):
lines.append(
f" (总识别次数: {fudai_seen_unique},其中 {len(prize_values)} 个成功识别到价值)"
)
lines.append(f"总价值: {total_value:.2f} 元")
lines.append(f"平均价值: {avg_value:.2f} 元")
lines.append(f"最高价值: {max_value:.2f} 元")
lines.append(f"最低价值: {min_value:.2f} 元")
# 价值分布
high_value_count = sum(1 for v in prize_values if v >= 500)
medium_value_count = sum(1 for v in prize_values if 100 <= v < 500)
low_value_count = sum(1 for v in prize_values if v < 100)
lines.append("")
lines.append("价值分布:")
lines.append(
f" 高价值(≥500元): {high_value_count} ({high_value_count/len(prize_values)*100:.1f}%)"
)
lines.append(
f" 中价值(100-500元): {medium_value_count} ({medium_value_count/len(prize_values)*100:.1f}%)"
)
lines.append(
f" 低价值(<100元): {low_value_count} ({low_value_count/len(prize_values)*100:.1f}%)"
)
lines.append("")
# 最近一次福袋信息
fudai_last = stats.get("fudai_last", {})
if fudai_last.get("content") or fudai_last.get("countdown"):
lines.append("=" * 60)
lines.append("最近一次福袋信息")
lines.append("=" * 60)
lines.append(f"内容: {fudai_last.get('content') or '-'}")
lines.append(f"倒计时: {fudai_last.get('countdown') or '-'}")
participants = fudai_last.get("participants")
copies = fudai_last.get("copies")
if participants is not None and copies is not None:
lines.append(f"参与人数/份数: {participants} / {copies}")
if participants > 0 and copies > 0:
ratio = participants / copies
lines.append(f" 中奖概率: {1/ratio*100:.2f}% (1/{ratio:.1f})")
prize_value = fudai_last.get("prize_value_yuan")
if prize_value is not None:
lines.append(f"奖品价值: {prize_value} 元")
updated_ts = fudai_last.get("updated_ts")
if updated_ts:
dt = datetime.fromtimestamp(updated_ts)
lines.append("更新时间: " + dt.strftime("%Y-%m-%d %H:%M:%S"))
lines.append("")
# 中奖记录
wins = stats.get("wins", [])
if wins:
lines.append("=" * 60)
lines.append(f"最近中奖记录(显示最近 {len(wins)} 条)")
lines.append("=" * 60)
for i, win in enumerate(wins[-10:], 1): # 只显示最近10条
ts = win.get("ts", 0)
dt_str = (
datetime.fromtimestamp(ts).strftime("%Y-%m-%d %H:%M:%S")
if ts
else "-"
)
lines.append(f"\n[{i}] 时间: {dt_str}")
if win.get("content"):
lines.append(f" 内容: {win.get('content')}")
if win.get("prize_value_yuan"):
lines.append(f" 价值: {win.get('prize_value_yuan')} 元")
if win.get("participants") and win.get("copies"):
lines.append(
f" 人数/份数: {win.get('participants')} / {win.get('copies')}"
)
# 确保至少显示基本信息
if not lines:
lines.append("=" * 60)
lines.append("统计信息")
lines.append("=" * 60)
lines.append("暂无统计数据")
lines.append("")
lines.append("提示:请先运行程序以收集统计数据")
stats_text.delete("1.0", "end")
stats_text.insert("1.0", "\n".join(lines))
except Exception as e:
import traceback
stats_text.delete("1.0", "end")
error_detail = traceback.format_exc()
stats_text.insert(
"1.0", f"刷新统计信息失败:{e}\n\n详细信息:\n{error_detail}"
)
ttk.Button(stats_top, text="刷新", command=refresh_stats).pack(side=LEFT)
# 预约队列显示
reservation_top = ttk.Frame(reservation_tab)
reservation_top.pack(fill=X, padx=10, pady=(10, 0))
reservation_text = ScrolledText(reservation_tab)
reservation_text.pack(fill=BOTH, expand=True, padx=10, pady=10)
try:
reservation_text.configure(font=("Consolas", 10))
except Exception:
pass
def refresh_reservations():
try:
from path_config import get_reservations_path
path = get_reservations_path()
except Exception:
# 回退到旧路径(向后兼容)
import path_config
path = path_config.get_reservations_path()
try:
if os.path.exists(path):
with open(path, "r", encoding="utf-8") as f:
data = json.load(f)
reservation_text.delete("1.0", "end")
updated_ts = (
float(data.get("updated_ts", 0.0) or 0.0)
if isinstance(data, dict)
else 0.0
)
room_pos = (
int(data.get("room_pos", 0) or 0) if isinstance(data, dict) else 0
)
reason = (
str(data.get("reason", "") or "") if isinstance(data, dict) else ""
)
current_title = (
str(data.get("current_room_title", "") or "")
if isinstance(data, dict)
else ""
)
current_title_raw = (
str(data.get("current_room_title_raw", "") or "")
if isinstance(data, dict)
else ""
)
reservations = (
data.get("reservations", []) if isinstance(data, dict) else []
)
# 基本信息(中文,更详细)
lines = []
lines.append("=" * 60)
lines.append("【预约队列总览】")
lines.append("=" * 60)
if updated_ts > 0:
try:
updated_dt = datetime.fromtimestamp(updated_ts)
updated_str = updated_dt.strftime("%Y年%m月%d日 %H:%M:%S")
# 计算距离现在的时间
now_dt = datetime.now()
time_diff = now_dt - updated_dt
if time_diff.total_seconds() < 60:
time_ago = f"{int(time_diff.total_seconds())}秒前"
elif time_diff.total_seconds() < 3600:
time_ago = f"{int(time_diff.total_seconds() // 60)}分钟前"
elif time_diff.total_seconds() < 86400:
time_ago = f"{int(time_diff.total_seconds() // 3600)}小时前"
else:
time_ago = f"{int(time_diff.total_seconds() // 86400)}天前"
lines.append(f"最后更新时间:{updated_str} ({time_ago})")
except Exception:
updated_str = str(updated_ts)
lines.append(f"最后更新时间:{updated_str}")
else:
lines.append("最后更新时间:暂无数据")
lines.append(
f"当前所在直播间位置:第 {room_pos + 1} 个直播间(索引:{room_pos})"
)
lines.append(f"当前直播间名称(清洗后):{current_title or '未知'}")
lines.append(f"当前直播间名称(原始):{current_title_raw or '未知'}")
lines.append(f"预约队列总数:{len(reservations)} 条")
if reason:
reason_map = {
"record_reservation": "记录新预约",
"update_reservation": "更新预约信息",
"remove_expired": "移除过期预约",
"sort_reservations": "重新排序预约",
}
reason_text = reason_map.get(reason, reason)
lines.append(f"最近更新原因:{reason_text}")
lines.append("")
# 统计信息
if reservations:
now_ts = datetime.now().timestamp()
total_value = 0.0
valid_future_times = []
expired_count = 0
upcoming_count = 0
for item in reservations:
try:
val = float(item.get("prize_value_yuan") or 0.0)
total_value += val
except Exception:
pass
ft = float(item.get("future_ts") or 0.0)
if ft > 0:
valid_future_times.append(ft)
remain_sec = ft - now_ts
if remain_sec <= 0:
expired_count += 1
elif remain_sec <= 300: # 5分钟内
upcoming_count += 1
lines.append("【统计信息】")
lines.append(f"预约总价值:{total_value:.2f} 元")
if len(reservations) > 0:
avg_value = total_value / len(reservations)
lines.append(f"平均价值:{avg_value:.2f} 元")
if valid_future_times:
earliest_ts = min(valid_future_times)
latest_ts = max(valid_future_times)
try:
earliest_str = datetime.fromtimestamp(earliest_ts).strftime(
"%Y-%m-%d %H:%M:%S"
)
latest_str = datetime.fromtimestamp(latest_ts).strftime(
"%Y-%m-%d %H:%M:%S"
)
lines.append(f"最早开奖时间:{earliest_str}")
lines.append(f"最晚开奖时间:{latest_str}")
except Exception:
pass
if expired_count > 0:
lines.append(f"⚠️ 已过期预约:{expired_count} 条")
if upcoming_count > 0:
lines.append(f"⏰ 即将开奖(5分钟内):{upcoming_count} 条")
lines.append("")
lines.append("=" * 60)
lines.append("【预约明细列表】(按预计开奖时间从早到晚排序)")
lines.append("=" * 60)
lines.append("")
for idx, item in enumerate(reservations, start=1):
try:
val = float(item.get("prize_value_yuan") or 0.0)
except Exception:
val = 0.0
content = str(item.get("content") or "")
ft = float(item.get("future_ts") or 0.0)
ft_str = str(item.get("future_str") or "")
pos_seen = int(item.get("pos_seen") or 0)
room_title = str(item.get("room_title") or "")
room_title_raw = str(item.get("room_title_raw") or "")
created_ts = float(item.get("created_ts") or 0.0)
# 计算剩余时间(更详细)
now_ts = datetime.now().timestamp()
remain_sec = ft - now_ts if ft > 0 else 0
if ft <= 0:
remain_str = "❌ 开奖时间无效"
status_icon = "❌"
elif remain_sec <= 0:
remain_str = "⏰ 已到开奖时间"
status_icon = "⏰"
elif remain_sec <= 60:
remain_str = f"🔥 即将开奖({int(remain_sec)}秒后)"
status_icon = "🔥"
elif remain_sec <= 300:
remain_str = f"⏰ 即将开奖({int(remain_sec // 60)}分{int(remain_sec % 60)}秒后)"
status_icon = "⏰"
elif remain_sec <= 3600:
remain_str = f"⏳ {int(remain_sec // 60)}分{int(remain_sec % 60)}秒后开奖"
status_icon = "⏳"
elif remain_sec <= 86400:
hours = int(remain_sec // 3600)
minutes = int((remain_sec % 3600) // 60)
remain_str = f"⏳ {hours}小时{minutes}分钟后开奖"
status_icon = "⏳"
else:
days = int(remain_sec // 86400)
hours = int((remain_sec % 86400) // 3600)
remain_str = f"📅 {days}天{hours}小时后开奖"
status_icon = "📅"
# 记录时间(更详细)
if created_ts > 0:
try:
created_dt = datetime.fromtimestamp(created_ts)
created_str = created_dt.strftime(
"%Y年%m月%d日 %H:%M:%S"
)
# 计算距离现在的时间
time_diff = datetime.now() - created_dt
if time_diff.total_seconds() < 3600:
time_ago = f"{int(time_diff.total_seconds() // 60)}分钟前记录"
elif time_diff.total_seconds() < 86400:
time_ago = f"{int(time_diff.total_seconds() // 3600)}小时前记录"
else:
time_ago = f"{int(time_diff.total_seconds() // 86400)}天前记录"
created_str_full = f"{created_str} ({time_ago})"
except Exception:
created_str_full = str(created_ts)
else:
created_str_full = "未知"
# 格式化显示
lines.append(
"┌─ 预约 #"
+ str(idx)
+ " ─────────────────────────────────────────────"
)
lines.append(f"│ 状态:{status_icon} {remain_str}")
lines.append("│")
lines.append(f"│ 💰 奖品价值:{val:.2f} 元")
lines.append(f"│ 📦 奖品内容:{content or '(无描述)'}")
lines.append("│")
lines.append(f"│ ⏰ 预计开奖时间:{ft_str or '未知'}")
if ft > 0:
try:
ft_dt = datetime.fromtimestamp(ft)
ft_str_detailed = ft_dt.strftime(
"%Y年%m月%d日 %H:%M:%S"
)
if ft_str_detailed != ft_str:
lines.append(f"│ 详细时间:{ft_str_detailed}")
except Exception:
pass
lines.append("│")
lines.append(
f"│ 📍 发现时直播间位置:第 {pos_seen + 1} 个直播间(索引:{pos_seen})"
)
lines.append(
f"│ 🏠 直播间名称(清洗后):{room_title or '未知'}"
)
lines.append(
f"│ 🏠 直播间名称(原始):{room_title_raw or '未知'}"
)
lines.append("│")
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
actions_current_match_index = _generic_search_widget(
actions_log_text,
actions_search_var,
actions_search_matches,
actions_current_match_index,
direction,
)
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:
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)
ttk.Button(
win_record_top,
text="实时查看",
command=(
lambda: (
_open_realtime_viewer_impl()
if callable(_open_realtime_viewer_impl)
else None
)
),
).pack(side=LEFT, padx=(8, 0))
# 误识别记录管理
false_positive_frame = ttk.LabelFrame(win_record_right, text="误识别记录管理")
false_positive_frame.pack(fill=X, pady=(10, 0))
false_positive_text = ScrolledText(false_positive_frame, height=6)
false_positive_text.pack(fill=X, padx=10, pady=10)
def load_false_positives():
"""加载误识别记录"""
try:
from path_config import get_pic_dir
pic_dir = get_pic_dir()
except Exception:
import path_config
pic_dir = path_config.get_pic_dir()
false_positive_file = os.path.join(
pic_dir, "lottery_prize_captures", "false_positives.json"
)
if not os.path.exists(false_positive_file):
false_positive_text.delete("1.0", "end")
false_positive_text.insert("1.0", "暂无误识别记录")
return
try:
with open(false_positive_file, "r", encoding="utf-8") as f:
data = json.load(f)
false_positives = data.get("false_positives", [])
false_positive_text.delete("1.0", "end")
if false_positives:
false_positive_text.insert("1.0", "\n".join(false_positives))
else:
false_positive_text.insert("1.0", "暂无误识别记录")
except Exception as e:
false_positive_text.delete("1.0", "end")
false_positive_text.insert("1.0", f"加载失败:{e}")
def save_false_positives():
"""保存误识别记录"""
try:
from path_config import get_pic_dir
pic_dir = get_pic_dir()
except Exception:
import path_config
pic_dir = path_config.get_pic_dir()
false_positive_file = os.path.join(
pic_dir, "lottery_prize_captures", "false_positives.json"
)
os.makedirs(os.path.dirname(false_positive_file), exist_ok=True)
content = false_positive_text.get("1.0", "end-1c")
lines = [line.strip() for line in content.splitlines() if line.strip()]
try:
with open(false_positive_file, "w", encoding="utf-8") as f:
json.dump({"false_positives": lines}, f, ensure_ascii=False, indent=2)
on_line(f"[中奖记录] 已保存 {len(lines)} 条误识别记录")
except Exception as e:
on_line(f"[中奖记录] 保存失败:{e}")
false_positive_btn_frame = ttk.Frame(false_positive_frame)
false_positive_btn_frame.pack(fill=X, padx=10, pady=(0, 10))
ttk.Button(
false_positive_btn_frame, text="刷新", command=load_false_positives
).pack(side=LEFT, padx=(0, 5))
ttk.Button(
false_positive_btn_frame, text="保存", command=save_false_positives
).pack(side=LEFT)
load_false_positives()
pump_logs()
def delayed_refresh_preview() -> None:
if image_var.get():
refresh_preview()
root.after(300, delayed_refresh_preview) # type: ignore[arg-type]
root.after(500, refresh_stats) # type: ignore[arg-type]
root.after(500, refresh_reservations) # type: ignore[arg-type]
root.after(500, refresh_high_value_rooms) # type: ignore[arg-type]
root.after(500, refresh_actions_log) # type: ignore[arg-type]
root.after(500, refresh_win_record) # type: ignore[arg-type]
# 定期刷新行为日志(每2秒)
def auto_refresh_actions_log() -> None:
refresh_actions_log()
root.after(2000, auto_refresh_actions_log) # type: ignore[arg-type]
# 定期刷新预约队列(每5秒)
def auto_refresh_reservations() -> None:
refresh_reservations()
root.after(5000, auto_refresh_reservations) # type: ignore[arg-type]
root.after(2000, auto_refresh_actions_log) # type: ignore[arg-type]
root.after(5000, auto_refresh_reservations) # type: ignore[arg-type]
# 定期刷新统计信息(每3秒)
def auto_refresh_stats() -> None:
if runner.is_running():
refresh_stats()
root.after(3000, auto_refresh_stats) # type: ignore[arg-type]
auto_refresh_stats()
def on_close():
try:
runner.stop()
except Exception:
pass
root.destroy()
root.protocol("WM_DELETE_WINDOW", on_close)
refresh_devices()
root.mainloop()
if __name__ == "__main__":
try:
from version import print_version_banner
print_version_banner("gui_app")
except Exception:
pass
main()