Files
douyi_guaji_main/douyin/core/douyin_fudai.py
T

691 lines
28 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.
"""
本地完整版 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
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_core
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_recommend_flow(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,则无限循环运行
from douyin.core.fudai_modules import fudai_run_loop as _run_loop
if wait_minutes and wait_minutes > 0:
_run_loop.run_timed_loop(self, int(wait_minutes))
else:
_run_loop.run_infinite_loop(self)
# ========== 阶段诊断 ==========
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) 为中心的 ROI 截图。"""
return douyin_screenshot_handler.ScreenshotHandler.capture_roi_screenshot(
self, label, sx, sy, size, screenshot_path
)
def _match_icon_template(
self, roi_path: str, template_path: str, threshold: float | None = None
) -> Tuple[bool, float]:
"""对比 ROI 与模板,返回 (detected, score)。"""
return douyin_screenshot_handler.ScreenshotHandler.match_icon_template(
self, roi_path, template_path, threshold
)
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()
# 直接参与标志已移除,相关旧逻辑已清理,继续按正常流程执行
# 0. 如果正在等待开奖:不在此期间检查并抢占其他预约,避免放弃当前正在参加的直播间
from douyin.core.fudai_modules import run_once_basic_helpers as _ronce_helpers
_ronce_helpers.run_once_basic_prelude(self, start_time)
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. 若启用高价值预约:先处理"是否需要回退到预约直播间"
if _ronce_helpers.handle_reservation_pipeline(self, start_time):
return
_ronce_helpers.run_once_basic_post_reservation(self, 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.live_room_handlers import handle_in_fudai_detail as _impl
return _impl(self)
def _handle_live_room_has_or_not_fudai(self) -> None:
"""在直播间:寻找福袋图标;有则点开详情,无则交给 flow_control 决定继续策略。"""
from douyin.core.fudai_modules.live_room_handlers import handle_live_room_has_or_not_fudai as _impl
return _impl(self)