Files
CodexandClaude Sonnet 4.5 bb90e2983f fix(pil): 补充修复剩余 PIL Image 资源泄漏
覆盖 14 个文件中的 Image.open() 未正确关闭问题:
- fansclub_handler: 5 处(pic/pic_rgb/img 未 close)
- image_ops: 2 处(crop 后 pic 未 close)
- douyin_popups: 2 处(pic.convert 重赋值泄漏原始句柄)
- douyin_fudai: 1 处(open().convert() 链式调用泄漏)
- douyin_robot: 2 处(同上)
- save_files/direct_attend/finder/stage/find_open/detail/_common/ocr_preprocess: 各 1-2 处

统一修复模式:分离 open 与 convert,try/finally 确保原始句柄关闭。

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
2026-05-23 22:49:50 +08:00

1352 lines
55 KiB
Python
Raw Permalink 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.
"""
本地完整版 douyin_fudai(模块化调度器)
======================================
目标:
- 不再依赖外部 axf 目录;
- 保持 `from douyin_fudai import fudai_analyse` 导入方式不变;
- 将核心逻辑拆分到各子模块,仅在此做"组装 + 调度"。
"""
from __future__ import annotations
from typing import Any, List, Tuple, Optional, cast
import os
import time
import subprocess
import logging
# Optional heavy dependencies used in image processing; Pylance may not have them in analysis env
from PIL import Image # type: ignore[import]
import numpy as np # type: ignore[import]
from douyin.core.underlying_operations import underlying_operations
from douyin.stage import douyin_stage
from douyin.detection import douyin_detection
from douyin.fudai import douyin_fudai_detail
from douyin.fudai import douyin_fudai_core
from douyin.core import douyin_flow_control # pylint: disable=redefined-outer-name
from douyin.other import douyin_live_room
from douyin.reservation import (
douyin_reservation_logic,
) # pylint: disable=redefined-outer-name
from douyin.utils import douyin_config
from douyin.logging import douyin_logging_wrapper
from douyin.handlers import douyin_screenshot_handler
from douyin.utils import douyin_helpers
from douyin.handlers import douyin_popup_handler
from douyin.handlers import douyin_swipe_handler
from douyin.reservation import douyin_reservation_handler
from douyin.stage import douyin_stage_handler
class fudai_analyse:
"""福袋抽奖相关操作类(本地模块化实现,保留原有属性与入口)。"""
# 类常量:魔法数字提取
MAX_BACK_CLICKS_TO_RECOMMEND = 10 # 返回推荐页面的最大返回键点击次数
BACK_KEY_CLICK_DELAY = 1.0 # 返回键点击后的延迟(秒)
PAGE_STABLE_DELAY = 2.0 # 页面稳定等待时间(秒)
FOLLOW_TAB_CLICK_DELAY = 2.0 # 点击关注标签后的延迟(秒)
ENTER_LIVE_CLICK_DELAY = 0.6 # 点击进入直播间的延迟(秒)
ENTER_LIVE_FINAL_DELAY = 2.0 # 进入直播间后的最终等待时间(秒)
def __init__(self) -> None:
# 设备与分辨率
self.device_id: str = "" # 设备ID,需要在运行时设置
self.y_pianyi: int = 0
self.resolution_ratio_x: int = 1080
self.resolution_ratio_y: int = 2400
# 滑动次数计数器(用于滑动次数重置功能)
self._swipe_times: int = 0
# 运行配置(只保留与你当前需求直接相关的主流程字段,细节统一放在各子模块内部)
self.operation = underlying_operations()
self.config_path = "config/config.json"
# 日志相关字段:完全独立的日志系统(不依赖原始代码)
try:
from datetime import datetime
self._run_id = datetime.now().strftime("%Y%m%d%H%M%S")
except Exception as e:
logging.debug("生成 run_id 失败,回退到时间戳: %s", e)
self._run_id = str(int(time.time()))
self._log_seq = 0
self._log_kv_orig = None
# 日志时间戳使用系统时间(不强制替换年份)
self._use_real_timestamp = False
# 使用增强版本(通过日志包装器)
self._log_kv = lambda *args, **kwargs: douyin_logging_wrapper.LoggingWrapper.enhanced_log_kv(
self, *args, **kwargs
)
# 用于跟踪上一个日志标签,以便检测阶段变化并添加分隔符
self._last_log_tag = None
# 预定义可在运行中动态创建的属性,避免 access-before-definition / attribute-defined-outside-init 警告
self._std_logger = None # type: ignore[assignment]
# 初始化统一日志系统和traceId
# 确保日志系统已配置(在实例化之前)
try:
from douyin.logging import douyin_logging
# 检查 _logging_configured 标志是否存在
if not getattr(douyin_logging, "_logging_configured", False):
douyin_logging.configure_logging()
except Exception as e:
logging.warning("日志系统初始化失败: %s", e)
try:
from douyin.logging.unified_logger import MDC, get_unified_logger
# 为当前实例设置traceId
MDC.set_trace_id(f"run_{self._run_id}")
self._std_logger = get_unified_logger("douyin.fudai")
except ImportError:
# 如果unified_logger不可用,使用标准logging
self._std_logger = logging.getLogger("douyin.fudai")
# 确保根 logger 有 handlers
root_logger = logging.getLogger()
if not root_logger.handlers:
try:
from douyin.logging import douyin_logging
douyin_logging.configure_logging()
except Exception:
pass
# 应用所有"配置默认值 + 运行时状态字段初始化"
from douyin.core.fudai_modules.init_helpers import apply_fudai_defaults
apply_fudai_defaults(self)
# 初次加载配置
self.load_config()
# ===== 兼容原始脚本的一些简单封装方法 =====
def _find_room_pos_by_title(
self, target_title: str, target_title_raw: str = ""
) -> int | None:
"""根据直播间标题在运行时映射表中查找对应的位置。
返回:
如果找到匹配的位置,返回位置值;否则返回 None
"""
return douyin_reservation_handler.ReservationHandler.find_room_pos_by_title(
self, target_title, target_title_raw
)
def _record_room_title_and_pos(self) -> None:
"""记录当前直播间的标题和位置到运行时映射表。
用于预约回退校验时验证位置信息。
"""
douyin_reservation_handler.ReservationHandler.record_room_title_and_pos(self)
def click(self, x: int, y: int) -> None:
"""兼容原版 fudai_analyse.click:转发到底层 operation.click。"""
douyin_helpers.HelperFunctions.click(self, x, y)
def swipe(
self, start_x: int, start_y: int, end_x: int, end_y: int, duration_ms: int = 300
) -> None:
"""兼容原版 fudai_analyse.swipe:转发到底层 operation.swipe。
参数使用像素坐标,duration_ms 为滑动持续时间(毫秒)。
"""
try:
# 首选底层 operation 的 swipe 实现
try:
self.operation.swipe(
self.device_id, start_x, start_y, end_x, end_y, duration_ms
)
return
except Exception:
pass
# 回退:尝试使用 douyin.handlers.douyin_swipe_ops 的 adb 命令直接发送
try:
from douyin.handlers import douyin_swipe_ops
ok = douyin_swipe_ops._adb_swipe_direct(
getattr(self, "device_id", ""),
start_x,
start_y,
end_x,
end_y,
duration_ms,
self.operation,
)
if ok:
return
except Exception:
pass
# 最后兜底:记录滑动失败
try:
self._log_kv(
"滑动",
"swipe 失败 - 无可用实现",
start_x=start_x,
start_y=start_y,
end_x=end_x,
end_y=end_y,
duration_ms=duration_ms,
)
except Exception:
pass
except Exception:
try:
self._log_kv(
"滑动",
"swipe 异常",
start_x=start_x,
start_y=start_y,
end_x=end_x,
end_y=end_y,
duration_ms=duration_ms,
)
except Exception:
pass
def load_config(self) -> None:
"""从 config.json 加载与福袋筛选/节流相关的关键参数(精简版)。"""
douyin_config.ConfigManager.load_config_from_file(self) # type: ignore[attr-defined]
# ===== 推荐页养号封装 =====
def _yanghao_recommend_flow(self, seconds: int) -> None:
"""封装调用 douyin.other.douyin_yanghao.yanghao_recommend_flow。"""
try:
# Respect global enable switch so callers that invoke this
# method directly cannot bypass the main on/off setting.
if not bool(getattr(self, "yanghao_enabled", True)):
try:
self._log_kv(
"养号", "_yanghao_recommend_flow skipped - yanghao_enabled=0"
)
except Exception:
logging.info("[养号] _yanghao_recommend_flow skipped - yanghao_enabled=0")
return
from douyin.other import douyin_yanghao
douyin_yanghao.yanghao_recommend_flow(self, int(seconds or 0))
except Exception:
# 兜底:若模块不可用则快速返回
try:
self._log_kv(
"养号", "_yanghao_recommend_flow 未能执行 - 模块缺失或异常"
)
except Exception:
pass
def _yanghao_wait(self, seconds: int) -> None:
"""封装调用 douyin.other.douyin_yanghao.yanghao_wait(可由主流程在等待阶段调用)。"""
try:
from douyin.other import douyin_yanghao
douyin_yanghao.yanghao_wait(self, int(seconds or 0))
except Exception:
try:
self._log_kv("养号", "_yanghao_wait 未能执行 - 模块缺失或异常")
except Exception:
pass
def _yanghao_get_recommend_seconds(self) -> int:
"""返回配置或默认的推荐页停留时长(秒)。"""
try:
from douyin.other import douyin_yanghao
return int(douyin_yanghao.yanghao_get_recommend_seconds(self))
except Exception:
try:
return int(
getattr(self, "yanghao_recommend_duration_seconds", 60) or 60
)
except Exception:
return 60
def _maybe_run_yanghao_during_run(self) -> None:
"""If configured, trigger recommendation-page yanghao at configured intervals.
This respects `yanghao_enabled` and will not trigger during lottery-result waiting.
"""
try:
interval = int(getattr(self, "yanghao_recommend_interval_seconds", 0) or 0)
if interval <= 0:
return
# 不在等待开奖期间触发养号
if getattr(self, "_waiting_for_lottery_result", False):
return
# 如果正在处理预约或有未完成的预约队列,则跳过触发
try:
if getattr(self, "_current_attending_reservation_fudai", False):
return
except Exception:
pass
try:
reservations = getattr(self, "reservations", None)
if reservations and len(reservations) > 0:
# 有预约队列,等待预约完成
return
except Exception:
pass
try:
reservation_focus_until = float(
getattr(self, "reservation_focus_until_ts", 0.0) or 0.0
)
if reservation_focus_until > time.time():
# 当前处于预约焦点期,跳过养号
return
except Exception:
pass
now = time.time()
last = float(getattr(self, "_last_yanghao_ts", 0.0) or 0.0)
if now - last < interval:
return
try:
self._log_kv("养号", "定时触发推荐页养号", interval_seconds=interval)
except Exception:
pass
self._last_yanghao_ts = now
seconds = int(getattr(self, "yanghao_recommend_duration_seconds", 60) or 60)
try:
self._yanghao_wait(seconds)
except Exception:
pass
except Exception:
pass
# ========== 兼容旧入口:主循环 ==========
def fudai_choujiang(
self,
device_id: str = "",
y_pianyi: int = 0,
needswitch: bool = False,
wait_minutes: int = 15,
) -> None:
"""兼容原 fudai1.fudai_choujiang 的主入口(当前实现为精简版:仅基础抢福袋)。"""
# 程序启动时清理旧截图文件,避免复用过期的截图
try:
from douyin.core import path_config
import os
pic_path = path_config.get_screenshot_path()
if os.path.exists(pic_path):
os.remove(pic_path)
self._log_kv(
"启动",
"清理旧截图文件,避免复用过期截图",
path=pic_path,
log_type="SCREENSHOT",
)
except Exception as e:
try:
self._log_kv(
"启动",
f"清理旧截图文件失败 - {str(e)}",
level="WARNING",
error=str(e),
)
except Exception:
pass
# DEBUG: 记录函数入口
try:
self._log_kv(
"DEBUG",
"entered fudai_choujiang",
device_id=device_id,
wait_minutes=wait_minutes,
)
except Exception:
logging.warning(
f"[DEBUG] entered fudai_choujiang device_id={device_id} wait_minutes={wait_minutes}"
)
self.device_id = device_id or self.device_id
self.y_pianyi = int(y_pianyi or 0)
# 保存是否允许切换直播间的配置,供后续所有逻辑统一使用
try:
self.needswitch = bool(needswitch)
except Exception:
# 兜底:若赋值失败,则保持原有行为(默认允许切换)
self.needswitch = True
# 尝试获取设备分辨率;若设备未连接则重试数次再回退到默认分辨率
resolved = False
if self.device_id:
for attempt in range(5):
try:
rx, ry = self.operation.get_device_resolution(self.device_id)
self.resolution_ratio_x = int(rx or 1080)
self.resolution_ratio_y = int(ry or 2400)
resolved = True
break
except Exception as e:
try:
self._log_kv(
"截图",
"获取分辨率失败,重试中",
attempt=attempt + 1,
error=str(e),
)
except Exception:
logging.warning(
f"[DEBUG] get_device_resolution attempt {attempt+1} failed: {e}"
)
time.sleep(1.0)
if not resolved:
# 回退到默认分辨率
try:
self._log_kv("截图", "使用默认分辨率回退", width=1080, height=2400)
except Exception:
pass
self.resolution_ratio_x, self.resolution_ratio_y = 1080, 2400
# 记录运行开始
from datetime import datetime
start_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
try:
try:
from douyin.core import path_config as _pc
actions_log_path = _pc.get_actions_log_path()
except Exception:
# 兜底:path_config 不可用时退化(不会推到 douyin/core/logs,沿用 PROJECT_ROOT/logs)
actions_log_path = os.path.join(
os.path.dirname(__file__), "..", "..", "logs", "actions.log"
)
actions_log_path = os.path.normpath(actions_log_path)
log_dir = os.path.dirname(actions_log_path)
if log_dir:
os.makedirs(log_dir, exist_ok=True)
with open(
actions_log_path, "a", encoding="utf-8-sig", errors="replace"
) as f:
f.write("=" * 80 + "\n")
f.write(f"{start_time} - [GUI] - [运行] 程序开始运行\n")
f.flush()
except Exception:
pass
# 捕获并记录未被捕获的异常以便排查立即退出问题
try:
# 原有后续逻辑继续...
pass
except Exception as top_exc:
try:
self._log_kv(
"ERROR", "fudai_choujiang top-level exception", error=str(top_exc)
)
except Exception:
import traceback
traceback.print_exc()
raise
# 暂时禁用流式截图,使用直接截图模式
self._log_kv("截图服务", "暂时禁用流式截图,使用直接截图模式")
self._log_kv(
"启动",
"fudai_choujiang 开始执行(基础版,仅抢当前直播间福袋,不含预约/高价值房间)",
分辨率=f"{self.resolution_ratio_x}x{self.resolution_ratio_y}",
needswitch=int(bool(self.needswitch)),
wait_minutes=int(wait_minutes),
)
# 基础循环:在限定时间内反复执行单轮逻辑
# 如果 wait_minutes <= 0,则无限循环运行
if wait_minutes and wait_minutes > 0:
end_ts = time.time() + int(wait_minutes) * 60
while time.time() < end_ts:
try:
self.run_once_basic()
except Exception as exc:
# 捕获异常,记录日志,但继续循环
try:
self._log_kv(
"循环",
"run_once_basic 异常",
error=str(exc),
error_type=type(exc).__name__,
)
except Exception:
pass
# 异常后稍作延迟再继续
try:
self.operation.delay(2.0)
except Exception:
time.sleep(2.0)
continue
# 为避免过于频繁截图,增加少量间隔
try:
self.operation.delay(1.0)
except Exception:
time.sleep(1.0)
# 记录运行结束(定时模式)
try:
end_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
try:
from douyin.core import path_config as _pc
actions_log_path = _pc.get_actions_log_path()
except Exception:
actions_log_path = os.path.normpath(
os.path.join(
os.path.dirname(__file__), "..", "..", "logs", "actions.log"
)
)
log_dir = os.path.dirname(actions_log_path)
if log_dir:
os.makedirs(log_dir, exist_ok=True)
with open(
actions_log_path, "a", encoding="utf-8-sig", errors="replace"
) as f:
f.write("=" * 80 + "\n")
f.write(f"{end_time} - [GUI] - [运行] 程序运行结束(时间到)\n")
f.flush()
except Exception:
pass
else:
# 无限循环模式(wait_minutes <= 0)
self._log_kv("循环", "进入无限循环模式(wait_minutes <= 0)")
while True:
try:
self.run_once_basic()
except KeyboardInterrupt:
# 允许 Ctrl+C 退出
self._log_kv("循环", "收到中断信号,退出循环")
# 记录运行结束
try:
end_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
try:
from douyin.core import path_config as _pc
actions_log_path = _pc.get_actions_log_path()
except Exception:
actions_log_path = os.path.normpath(
os.path.join(
os.path.dirname(__file__), "..", "..", "logs", "actions.log"
)
)
log_dir = os.path.dirname(actions_log_path)
if log_dir:
os.makedirs(log_dir, exist_ok=True)
with open(
actions_log_path,
"a",
encoding="utf-8-sig",
errors="replace",
) as f:
f.write("=" * 80 + "\n")
f.write(
f"{end_time} - [GUI] - [运行] 程序运行结束(中断退出)\n"
)
f.flush()
except Exception:
pass
raise
except Exception as exc:
# 捕获异常,记录日志,但继续循环
try:
self._log_kv(
"循环",
"run_once_basic 异常",
error=str(exc),
error_type=type(exc).__name__,
)
except Exception:
pass
# 异常后稍作延迟再继续
try:
self.operation.delay(2.0)
except Exception:
time.sleep(2.0)
continue
# 为避免过于频繁截图,增加少量间隔
try:
self.operation.delay(1.0)
except Exception:
time.sleep(1.0)
# ========== 阶段诊断 ==========
def _diagnose_stage_from_current_screen(
self, force_screenshot: bool = False, trigger_reason: str = "unknown"
) -> Tuple[str, str]:
"""封装到子模块的阶段诊断入口。
参数:
force_screenshot: 是否强制重新截图(默认False,优先使用缓存)
"""
return douyin_stage_handler.StageHandler.diagnose_stage_from_current_screen(
self, force_screenshot=force_screenshot, trigger_reason=trigger_reason
)
# ========== 截图 / 裁剪 / 图标检测(供阶段诊断等调用) ==========
def cut_pic(
self,
x_top: int = 1,
y_top: int = 1,
x_bottom: int = 2,
y_bottom: int = 2,
target: str = "",
cut_pic_name: str = "",
y_pianyi: int = 0,
) -> None:
"""裁剪图片:保持与原 fudai1.cut_pic 相同的坐标语义(1080x2400 基准)。"""
douyin_screenshot_handler.ScreenshotHandler.cut_pic(
self, x_top, y_top, x_bottom, y_bottom, target, cut_pic_name, y_pianyi
)
def _read_pixel_stage_state(
self, return_details: bool = False
) -> dict | tuple[dict, dict]:
"""读取像素阶段状态(用于阶段诊断)。
参数:
return_details: 是否返回每个检测步骤的详细信息(包括分数)
返回:
dict: 检测结果(return_details=False时)
tuple[dict, dict]: (检测结果, 详细信息)(return_details=True时)
"""
return douyin_helpers.HelperFunctions.read_pixel_stage_state(
self, return_details
)
def _scale_from_base(self, base_x: int, base_y: int) -> tuple[int, int]:
"""将以 1080x2400 为基准的坐标缩放到当前设备分辨率并应用 y 偏移。
返回 (scaled_x, scaled_y)
"""
return douyin_screenshot_handler.ScreenshotHandler.scale_from_base(
self, base_x, base_y
)
def _save_step_screenshot(self, label: str) -> None:
"""保存当前截图到 `pic/steps/` 目录,文件名包含 run_id 与序号,供调试与回放使用。"""
douyin_screenshot_handler.ScreenshotHandler.save_step_screenshot(self, label)
def _capture_roi_screenshot(
self, label: str, sx: int, sy: int, size: int, screenshot_path: str = None
) -> str:
"""捕获以 (sx,sy) 为中心,边长为 size 的 ROI 截图,保存到 `pic/` 并返回路径。
返回 ROI 图片路径(绝对路径),失败返回空字符串。
"""
try:
from douyin.core import path_config
# use module-level `Image`
# 确保有最新全图
if screenshot_path is None:
try:
self.operation.get_screenshot(self.device_id, use_service=False)
except Exception:
pass
pic_path = path_config.get_screenshot_path()
else:
pic_path = screenshot_path
if not os.path.exists(pic_path):
return ""
# 计算裁剪框(保证正方形,size 基于像素)
half = int(size // 2)
left = int(max(0, sx - half))
top = int(max(0, sy - half))
right = int(sx + half)
bottom = int(sy + half)
# 以原子方式读取文件内容再由 PIL 解析,避免因文件替换/锁定导致的半写入问题
import io
from PIL import UnidentifiedImageError # type: ignore[import]
data = None
# 增强读取:多次尝试并在每次读到字节后用 PIL 验证,避免半写入/损坏 PNG 导致解析异常
for attempt in range(6):
try:
try:
# 主动请求最新截图以尽量获得完整文件
self.operation.get_screenshot(self.device_id, use_service=False)
except Exception:
pass
if not os.path.exists(pic_path):
time.sleep(0.08)
continue
sz = os.path.getsize(pic_path)
if sz < 1024:
time.sleep(0.08)
continue
with open(pic_path, "rb") as f:
data = f.read()
if not data or not data.startswith(b"\x89PNG"):
data = None
time.sleep(0.08)
continue
# quick tail check
if b"IEND" not in data[-512:]:
data = None
time.sleep(0.08)
continue
# 尝试由 PIL 快速验证(不加载像素,仅检查文件完整性)
try:
img_test = Image.open(io.BytesIO(data))
img_test.verify()
except Exception:
data = None
time.sleep(0.08)
continue
# 通过基本校验,退出重试循环
break
except Exception:
data = None
time.sleep(0.08)
if not data:
return ""
try:
img = Image.open(io.BytesIO(data))
img.load()
except UnidentifiedImageError:
return ""
except Exception:
# 如果首次解析仍然失败,尝试再获取一次截图并重试一次
try:
try:
self.operation.get_screenshot(self.device_id, use_service=False)
except Exception:
pass
with open(pic_path, "rb") as f:
data2 = f.read()
if (
data2
and data2.startswith(b"\x89PNG")
and b"IEND" in data2[-512:]
):
try:
img = Image.open(io.BytesIO(data2))
img.load()
except Exception:
return ""
else:
return ""
except Exception:
return ""
w, h = img.size
# 修正边界
left = max(0, min(left, w - 1))
top = max(0, min(top, h - 1))
right = max(1, min(right, w))
bottom = max(1, min(bottom, h))
roi = img.crop((left, top, right, bottom))
img.close()
# 保存到 pic 目录,使用 label 区分
out_dir = path_config.get_pic_dir()
os.makedirs(out_dir, exist_ok=True)
fname = (
f"roi_{label}_{getattr(self, '_run_id', 'run')}_{int(time.time())}.png"
)
out_path = os.path.join(out_dir, fname)
roi.save(out_path)
return out_path
except Exception:
try:
self._log_kv(
"截图",
"_capture_roi_screenshot 失败",
label=label,
sx=sx,
sy=sy,
size=size,
)
except Exception:
pass
return ""
def _match_icon_template(
self, roi_path: str, template_path: str, threshold: float | None = None
) -> Tuple[bool, float]:
"""对比 ROI 与模板,返回 (detected: bool, score: float)。
使用 PIL + numpy 计算归一化相关系数作为匹配分数(-1..1)。
如果提供 `threshold` 则使用该阈值判断匹配,否则回退到配置 `yanghao_icon_match_threshold`。
返回 (detected, score),若发生错误或文件缺失返回 (False, 0.0)。
"""
try:
if not roi_path or not os.path.exists(roi_path):
return False, 0.0
if not template_path or not os.path.exists(template_path):
return False, 0.0
# use module-level `Image` and `np` imports
_roi_raw = Image.open(roi_path)
_tpl_raw = Image.open(template_path)
try:
roi_img = _roi_raw.convert("RGB")
tpl_img = _tpl_raw.convert("RGB")
finally:
_roi_raw.close()
_tpl_raw.close()
rw, rh = roi_img.size
tw, th = tpl_img.size
# 若模板比 ROI 大,等比缩小模板
if tw > rw or th > rh:
scale = min(rw / tw, rh / th, 1.0)
new_w = max(1, int(tw * scale))
new_h = max(1, int(th * scale))
tpl_img = tpl_img.resize((new_w, new_h), Image.Resampling.LANCZOS)
tw, th = tpl_img.size
# 转为灰度数组
roi_gray = np.asarray(roi_img.convert("L"), dtype=np.float32)
tpl_gray = np.asarray(tpl_img.convert("L"), dtype=np.float32)
# 若模板尺寸等于 ROI,则直接计算相关系数
if (
roi_gray.shape[0] == tpl_gray.shape[0]
and roi_gray.shape[1] == tpl_gray.shape[1]
):
A = roi_gray.flatten()
B = tpl_gray.flatten()
else:
# 若模板小于 ROI,则优先取 ROI 中心区域与模板尺寸一致的裁剪进行比对(更稳健),
# 如果中心裁剪分数很低再退回到滑动搜索(成本较高)
ih, iw = roi_gray.shape
th, tw = tpl_gray.shape
# 计算中心裁剪窗口
if ih >= th and iw >= tw:
cy = ih // 2 - th // 2
cx = iw // 2 - tw // 2
cy = max(0, min(cy, ih - th))
cx = max(0, min(cx, iw - tw))
window = roi_gray[cy : cy + th, cx : cx + tw]
a = window.flatten()
b = tpl_gray.flatten()
a = a - a.mean()
b = b - b.mean()
denom = np.linalg.norm(a) * np.linalg.norm(b)
if denom > 1e-6:
score = float(np.dot(a, b) / denom)
else:
score = -1.0
# 若中心裁剪得分足够好则直接返回
if score >= 0.55:
used_thr = (
float(threshold)
if threshold is not None
else float(
getattr(self, "yanghao_icon_match_threshold", 0.70)
or 0.70
)
)
detected = score >= used_thr
return bool(detected), float(score)
# 退回到滑动搜索(简易版),保留原有步长策略
ih, iw = roi_gray.shape
th, tw = tpl_gray.shape
best = -1.0
step_y = max(1, th // 6)
step_x = max(1, tw // 6)
for y in range(0, ih - th + 1, step_y):
for x in range(0, iw - tw + 1, step_x):
window = roi_gray[y : y + th, x : x + tw]
a = window.flatten()
b = tpl_gray.flatten()
a = a - a.mean()
b = b - b.mean()
denom = np.linalg.norm(a) * np.linalg.norm(b)
if denom <= 1e-6:
continue
score = float(np.dot(a, b) / denom)
if score > best:
best = score
if best < -0.5:
return False, 0.0
score = float(best)
used_thr = (
float(threshold)
if threshold is not None
else float(
getattr(self, "yanghao_icon_match_threshold", 0.70) or 0.70
)
)
detected = score >= used_thr
return bool(detected), float(score)
# 同尺寸直接计算相关系数
A = roi_gray.flatten()
B = tpl_gray.flatten()
A = A - A.mean()
B = B - B.mean()
denom = np.linalg.norm(A) * np.linalg.norm(B)
if denom <= 1e-6:
return False, 0.0
score = float(np.dot(A, B) / denom)
used_thr = (
float(threshold)
if threshold is not None
else float(getattr(self, "yanghao_icon_match_threshold", 0.70) or 0.70)
)
detected = score >= used_thr
return bool(detected), float(score)
except Exception:
try:
self._log_kv(
"检测",
"_match_icon_template 异常",
roi_path=roi_path,
template_path=template_path,
)
except Exception:
pass
return False, 0.0
def _check_in_live_room_by_icon(
self,
) -> Tuple[bool, float]: # pyright: ignore[reportAttributeAccessIssue]
"""通过右上角关闭/心形图标进行直播间图形识别(轻量模板匹配版)。
返回:
(detected, score) 其中 score 为匹配得分(0.0~1.0,来自 TM_CCOEFF_NORMED)。
"""
return douyin_stage_handler.StageHandler.check_in_live_room_by_icon(self)
def check_in_fudai_detail(self) -> bool:
"""判断当前是否处于福袋详情页:委托给 douyin_detection.check_in_fudai_detail。"""
try:
return bool(douyin_detection.check_in_fudai_detail(self))
except Exception as exc:
try:
self._log_kv("检测", "check_in_fudai_detail 异常", error=str(exc))
except Exception:
pass
return False
def _enhanced_log_kv(self, *args, **fields):
"""增强的日志记录方法:始终输出到 stdout(供 GUI 捕获),同时可选输出到标准 logging"""
douyin_logging_wrapper.LoggingWrapper.enhanced_log_kv(self, *args, **fields)
# 供像素/检测模块记录子步骤耗时使用
def _log_step_time(
self, step_name: str, start_time: float, extra_info: dict | None = None
) -> None:
"""记录某个子步骤的耗时(供检测模块调用,减少日志噪音)。"""
douyin_logging_wrapper.LoggingWrapper.log_step_time(
self, step_name, start_time, extra_info
)
# ========== 弹窗 / 人机校验 ==========
def _check_coupon_popup(self) -> bool:
"""购物券 / 新客专享券 等底部营销弹窗(仅在详情链路外的"看门狗"中使用)。"""
return douyin_popup_handler.PopupHandler.check_coupon_popup(self)
def _check_shopping_redpacket_popup(self) -> bool:
"""购物红包中央弹窗。"""
return douyin_popup_handler.PopupHandler.check_shopping_redpacket_popup(self)
# ========== 主循环骨架(基础抢福袋 + 简化预约抢占) ==========
def run_once_basic(self) -> None: # type: ignore[complexity]
"""单轮基础抢福袋流程(包含简化版高价值福袋预约回退)。
注意:此方法复杂度较高,已通过模块化重构将部分逻辑拆分到子模块。
"""
# use module-level `douyin_reservation_logic` imported at top
start_time = time.time()
self._log_kv("流程", "run_once_basic开始", start_timestamp=start_time)
# 在主循环开始时检查是否需要定时触发推荐页养号
try:
self._maybe_run_yanghao_during_run()
except Exception:
pass
# 尝试记录当前直播间的标题与位置,确保所有直播间(不限福袋)都被采集到运行时映射表
# 但如果刚刚切换直播间,避免重复记录(切换前已记录)
try:
just_switched = getattr(self, "_just_switched_room", False)
if not just_switched:
self._record_room_title_and_pos()
else:
self._log_kv(
"预约",
"[预约] 刚刚切换直播间,跳过重复记录标题",
reason="avoid_duplicate_after_switch",
)
except Exception:
pass
# 直接参与标志已移除,相关旧逻辑已清理,继续按正常流程执行
# 0. 如果正在等待开奖:不在此期间检查并抢占其他预约,避免放弃当前正在参加的直播间
from douyin.core.fudai_modules import run_once_basic_helpers as _ronce_helpers
if _ronce_helpers.handle_waiting_for_lottery_result(self, start_time):
return
# 0. 检查30分钟超时:如果30分钟没有成功参与福袋,则返回推荐页面并重新进入直播间
if _ronce_helpers.handle_no_attend_timeout(self, start_time):
return
# 0.1. 若启用高价值预约:先处理"是否需要回退到预约直播间"
reservation_check_start = time.time()
if _ronce_helpers.handle_reservation_check(self, start_time):
return
# 检查是否刚刚记录了预约,如果是,强制切换直播间,避免在同一直播间循环
if _ronce_helpers.handle_just_recorded_reservation(self, start_time):
return
# 预约检查耗时记录
reservation_elapsed = time.time() - reservation_check_start
self._log_kv("预约", f"预约检查完成,耗时: {reservation_elapsed:.3f}s")
# 0.5. 检查是否需要跳过阶段检测,直接查找福袋(点击参与抽奖后)
if _ronce_helpers.handle_skip_stage_diagnosis(self, start_time):
return
# 1. 截图 + 阶段诊断
diag = _ronce_helpers.screenshot_and_diagnose(self, start_time)
if diag is None:
return
stage, seen = diag
# 1.5. 检测是否意外返回桌面(不在抖音前台),若是则尝试恢复
if _ronce_helpers.handle_desktop_recovery(self):
return
# 2. 诊断后分支(弹窗检测已合并到阶段诊断中)
# 2.0. 高价值房间重访检查(在处理其他状态之前)
if _ronce_helpers.handle_high_value_room_revisit(self, start_time):
return
# 处理弹窗 / 详情 / 直播间 / 推荐页 / 开奖结果 / 直播结束 阶段分发
_ronce_helpers.dispatch_stage_branch(self, stage, seen, start_time)
def _check_lottery_result_by_ocr(self) -> Optional[str]:
"""通过OCR识别开奖结果按钮区域,返回识别到的文本类型。"""
return douyin_helpers.HelperFunctions.check_lottery_result_by_ocr(self)
def _handle_lottery_result_by_ocr(self, result_type: str) -> None:
"""根据OCR识别结果处理开奖结果。
参数:
result_type: "我知道了" 或 "立即领取奖品"
"""
douyin_helpers.HelperFunctions.handle_lottery_result_by_ocr(self, result_type)
def _shot_and_diagnose(
self, tag: str, msg: str, device_id: str, diagnose: bool = True
) -> None:
"""截图并执行阶段诊断(兼容旧版调用方式)。
Args:
tag: 日志标签
msg: 日志消息
device_id: 设备ID
diagnose: 是否执行阶段诊断(默认True)
"""
douyin_helpers.HelperFunctions.shot_and_diagnose(
self, tag, msg, device_id, diagnose
)
# ========== 基础动作封装 ==========
def swipe_up_to_next_live(self) -> None:
"""上滑切换直播间(简单版封装)。
注意:如果处于预约锁定期内(reservation_focus_until_ts > 当前时间),
则不允许上划离开预约直播间,直接返回。
"""
douyin_swipe_handler.SwipeHandler.swipe_up_to_next_live(self)
def _return_to_recommend_and_reenter_live(self) -> None:
"""返回推荐页面并重新进入直播间。
通过多次点击返回键返回到推荐页面,然后点击关注标签并进入直播间。
"""
douyin_swipe_handler.SwipeHandler.return_to_recommend_and_reenter_live(self)
def swipe_down_back_from_live(self) -> None:
"""上划回退到上一个直播间(供预约/无福袋逻辑使用)。"""
douyin_swipe_handler.SwipeHandler.swipe_down_back_from_live(self)
def _maybe_reset_after_swipes(self) -> int:
"""达到切换阈值后,在当前直播间页面回退到第一个直播间。
返回:
重置后的滑动次数(通常为0)
"""
return douyin_swipe_handler.SwipeHandler.maybe_reset_after_swipes(self)
def _seek_reservation_room(
self, item: dict[str, Any], operation_type: str = "预约"
) -> bool:
"""根据预约记录里的 pos_seen 与当前 room_pos 进行回退,靠近目标直播间。
说明:
- 使用 high_value_fudai_max_swipe_back 约束最大回退次数;
- 如果启用了回退校验,会进行详细校验(直播间名、福袋详情匹配)。
"""
return douyin_reservation_handler.ReservationHandler.seek_reservation_room(
self, item, operation_type=operation_type
)
# ========== 福袋相关 ==========
def _handle_reservation_direct_attend(self) -> None:
"""预约回退后直接参与:直接使用预约记录中的详情,跳过OCR识别。"""
douyin_reservation_handler.ReservationHandler.handle_reservation_direct_attend(
self
)
# pylint: disable=too-many-nested-blocks
def _handle_in_fudai_detail(self) -> None:
"""已经在福袋详情页:只跑详情识别 + 是否参与的基础逻辑。"""
from douyin.core.fudai_modules import handle_detail_helpers as _hd_helpers
start_time = time.time()
_hd_helpers.log_entry_flags(self)
# 注意:点击参与抽奖后会自动关闭详情页,下次循环会跳过阶段检测直接查找福袋
# 检查连续参与失败次数,避免卡死
if _hd_helpers.handle_consecutive_failures_check(self):
return
# 步骤1:检查是否是第二次打开福袋详情
step1_start = time.time()
is_second_open = getattr(self, "_fudai_detail_first_read", False)
if is_second_open:
# 第二次打开分支已抽到 handle_second_open_branch
if _hd_helpers.handle_second_open_branch(self, start_time, step1_start):
return
# 异常或兜底重读时 fall through 到正常流程
else:
# 步骤2 + 步骤3:第一次打开分支已抽到 handle_first_open_branch
if _hd_helpers.handle_first_open_branch(self, start_time):
return
# 检查是否是优惠券弹窗、观看任务或识别错误:如果检测到,应该直接跳过,不继续处理
if _hd_helpers.check_last_status_branch(self, start_time):
return
# 重新取 detail(first-open / second-open 可能已 cache 到 self._last_fudai_detail_tuple)
detail = getattr(self, "_last_fudai_detail_tuple", None)
# 如果成功读取,重置失败计数
try:
self._fudai_detail_consecutive_failures = 0
except Exception:
pass
# 额外验证:使用验证函数检查数据合理性
try:
if detail is None:
try:
self._log_kv("福袋详情", "详情数据为 None,跳过验证")
except Exception:
pass
else:
is_valid, reason = douyin_fudai_detail.validate_fudai_detail(
detail, self
)
if not is_valid:
# 按钮状态为可操作时,即使验证失败也继续走参与流程
_ACTIONABLE = {
"可以参与", "需要加入粉丝团", "需要评论",
"需要观看", "已参与",
}
_btn_st = getattr(self, "_fudai_button_status", None)
if _btn_st in _ACTIONABLE:
try:
self._log_kv(
"流程",
"_handle_in_fudai_detail:验证失败但按钮可操作,继续参与",
validation_reason=reason,
button_status=_btn_st,
)
except Exception:
pass
else:
try:
self._log_kv(
"流程",
"_handle_in_fudai_detail:福袋详情数据验证失败,识别出错",
validation_reason=reason,
)
except Exception:
pass
douyin_fudai_detail.close_fudai_detail(self)
# 清除任务数量标志
_hd_helpers._clear_task_count_flag(self)
elapsed = time.time() - start_time
self._log_kv(
"流程",
"_handle_in_fudai_detail完成(验证失败)",
elapsed_seconds=round(elapsed, 2),
)
return
except Exception:
pass
# 兜底检查:如果价值为0且内容为空,也可能是优惠券弹窗或识别错误
if _hd_helpers.check_invalid_detail_fallback(self, detail, start_time):
return
# 步骤3 末尾准备:记录参与前状态、提取 future_ts、重置 _detail_closed_by_attend
attend_before_ts = _hd_helpers.prepare_for_attend(self, detail)
# 步骤4:参与决策(已抽到 handle_detail_helpers.step4_make_join_decision)
# skip / skip_reason 已在 first-open 分支处理;fall-through 到此处时认为是"立即参与"
_hd_helpers.step4_make_join_decision(
self, detail, False, "", attend_before_ts, start_time
)
def _handle_live_room_has_or_not_fudai(self) -> None:
"""在直播间:寻找福袋图标;有则点开详情,无则交给 flow_control 决定"继续找/切换/养号"."""
start_time = time.time()
# 设置当前参与的福袋类型为高价值福袋(非预约)
self._current_attending_reservation_fudai = False
# 先检查是否已经在福袋详情页(可能阶段诊断没有正确识别)
# 如果已验证过详情页但任务数为0,说明详情页正在加载,不应该再次查找福袋
try:
already_verified = bool(
getattr(self, "_fudai_detail_verified", False) or False
)
if already_verified:
try:
self._log_kv(
"流程",
"_handle_live_room_has_or_not_fudai:已验证过详情页,直接处理详情,不查找福袋",
)
except Exception:
pass
# 直接调用详情处理逻辑,不查找福袋
self._handle_in_fudai_detail()
elapsed = time.time() - start_time
self._log_kv(
"流程",
"_handle_live_room_has_or_not_fudai完成(已验证详情页)",
elapsed_seconds=round(elapsed, 2),
)
return
except Exception:
pass
# 检查是否在锁定期内,且时间窗口未到,避免重复打开福袋详情
try:
now_ts = time.time()
focus_until = float(getattr(self, "reservation_focus_until_ts", 0.0) or 0.0)
queue_full_waiting = bool(
getattr(self, "queue_full_waiting_at_earliest", False) or False
)
if focus_until > 0 and now_ts < focus_until and queue_full_waiting:
# 在锁定期内,且队列满等待中,检查时间窗口
if self.reservations and len(self.reservations) > 0:
earliest = self.reservations[0]
try:
ft = float(earliest.get("future_ts") or 0.0)
if ft > 0:
join_ahead = float(
getattr(
self, "high_value_fudai_join_ahead_seconds", 100
)
or 120
)
time_window_start_ts = ft - join_ahead
# 如果时间窗口未到,避免重复打开福袋详情
if now_ts < time_window_start_ts:
try:
self._log_kv(
"预约",
"[预约] 锁定期内时间窗口未到,避免重复打开福袋详情",
focus_until=int(focus_until),
now_ts=int(now_ts),
time_window_start=int(time_window_start_ts),
remain_seconds=int(
time_window_start_ts - now_ts
),
)
except Exception:
pass
elapsed = time.time() - start_time
self._log_kv(
"流程",
"_handle_live_room_has_or_not_fudai完成(锁定期内时间窗口未到)",
elapsed_seconds=round(elapsed, 2),
)
return
except Exception:
pass
except Exception:
pass
room_pos_ref: List[int] = [0]
opened = douyin_flow_control.find_and_open_fudai_detail(self, room_pos_ref)
if not opened:
# 无福袋,交给 flow_control 的“无福袋处理”逻辑
# 根据配置决定是否允许切换直播间(needswitch=False 时只等待不切房)
try:
need_switch_config = bool(getattr(self, "needswitch", True))
except Exception:
need_switch_config = True
wait_times_ref = [0]
swipe_times_ref = [0]
reservation_focus_until_ts_ref = [0.0]
reset_to_list_after_reservations_ref = [False]
douyin_flow_control.handle_no_fudai_situation(
self,
x=0,
swipe_times=0,
wait_times_ref=wait_times_ref,
needswitch=need_switch_config,
reservation_focus_until_ts=0.0,
reservations=[],
room_pos=room_pos_ref[0],
post_switch_delay_s=1.5,
swipe_up_switch_callback=self.swipe_up_to_next_live,
swipe_down_back_callback=lambda: None,
sort_reservations_callback=lambda: None,
clear_reservations_callback=lambda: None,
write_state_callback=lambda: None,
back_to_list_callback=lambda: None,
into_list_callback=lambda: None,
reservation_focus_until_ts_ref=reservation_focus_until_ts_ref,
reset_to_list_after_reservations_ref=reset_to_list_after_reservations_ref,
swipe_times_ref=swipe_times_ref,
)
elapsed = time.time() - start_time
self._log_kv(
"流程",
"_handle_live_room_has_or_not_fudai完成(无福袋)",
elapsed_seconds=round(elapsed, 2),
)
return
# 成功打开详情:调用同一套详情处理逻辑
self._handle_in_fudai_detail()
elapsed = time.time() - start_time
self._log_kv(
"流程",
"_handle_live_room_has_or_not_fudai完成(成功打开详情)",
elapsed_seconds=round(elapsed, 2),
)