覆盖 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>
1352 lines
55 KiB
Python
1352 lines
55 KiB
Python
"""
|
||
本地完整版 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),
|
||
)
|