Files
douyi_guaji_main/douyin/reservation/reservation_logic/attend_window.py
T

775 lines
28 KiB
Python

"""reservation_logic.attend_window - 进入预约窗口的处理(最大头)。
process_reservation_attend_window:当临近某条预约的开奖时间时,
抢占当前流程,回退到目标直播间,再触发详情识别与参与逻辑。
包含回退路径选择、回退校验、超时保护、失败重试等。
"""
from __future__ import annotations
import time
from typing import Any, Callable, Dict, List, Optional
from ._common import (
_RESERVATION_ERROR_UTILS_AVAILABLE,
ReservationItem,
format_reservation_context,
log_reservation_error,
safe_write_state,
)
from .cleanup_validate import cleanup_expired_reservations
from .helpers import (
_calculate_string_similarity,
_extract_content_core,
_normalize_room_title_for_matching,
_now_ts,
_sort_reservations_inplace,
)
from .attend_window_helpers import (
compute_dynamic_ahead,
log_attend_window_result,
log_back_failed_keep_queue,
log_target_snapshot,
mark_reservation_focus_and_log_success,
pop_if_already_participated,
pop_if_invalid_future_ts,
)
def process_reservation_attend_window(
analyser: Any,
reservations: List[ReservationItem],
room_pos: int,
reservation_focus_until_ts_ref: List[float],
reservation_after_action_pending_ref: List[bool],
reservation_back_swipe_delay_s: float,
swipe_down_back_callback: Callable[[], None],
seek_reservation_room_callback: Callable[[ReservationItem], bool],
sort_reservations_callback: Callable[[], None],
write_state_callback: Callable[[], None],
) -> bool:
"""在主循环中调用:处理"是否需要回退到某个预约直播间并参与"。
返回:
bool: 若为 True,表示已经触发了回退/跳转,本轮主循环应尽快结束,
让上层逻辑继续后续处理(例如识别详情并参与)。
"""
start_time = time.time()
# 总超时兜底:避免预约分支在某些机型/状态下长时间阻塞导致主循环“看似卡死”。
try:
total_timeout_s = float(
getattr(analyser, "reservation_back_total_timeout_seconds", 20.0) or 20.0
)
except Exception:
total_timeout_s = 20.0
# 添加函数入口日志
try:
analyser._log_kv(
"预约",
"[预约] process_reservation_attend_window 函数入口",
reservations_count=len(reservations) if reservations else 0,
room_pos=room_pos,
)
except Exception as e:
if _RESERVATION_ERROR_UTILS_AVAILABLE:
log_reservation_error(
analyser,
e,
format_reservation_context(reservations=reservations),
level="WARNING",
stage="记录函数入口日志",
)
else:
pass
# 检查是否正在等待开奖且当前参与的是预约福袋,如果是则不抢占
try:
waiting_for_lottery = bool(
getattr(analyser, "_waiting_for_lottery_result", False)
)
current_attending_reservation = bool(
getattr(analyser, "_current_attending_reservation_fudai", False)
)
if waiting_for_lottery and current_attending_reservation:
try:
analyser._log_kv(
"预约",
"[预约] 正在等待预约福袋开奖,不抢占其他预约",
waiting_for_lottery=waiting_for_lottery,
current_attending_reservation=current_attending_reservation,
)
except Exception:
pass
return False
except Exception as e:
if _RESERVATION_ERROR_UTILS_AVAILABLE:
log_reservation_error(
analyser,
e,
format_reservation_context(reservations=reservations),
level="WARNING",
stage="检查是否正在等待预约福袋开奖",
)
else:
pass
if not reservations:
try:
analyser._log_kv(
"预约",
"[预约] process_reservation_attend_window:预约队列为空,跳过",
)
except Exception as e:
if _RESERVATION_ERROR_UTILS_AVAILABLE:
log_reservation_error(
analyser,
e,
{},
level="WARNING",
stage="记录队列为空日志",
)
else:
pass
return False
now_ts = _now_ts()
focus_until = float(
reservation_focus_until_ts_ref[0] if reservation_focus_until_ts_ref else 0.0
)
# 用于锁定期判断/匹配的轮询提前量(允许为 0,禁止为负数)
try:
poll_before = float(
getattr(analyser, "high_value_fudai_poll_before_seconds", 10.0) or 10.0
)
except Exception:
poll_before = 10.0
poll_before = max(0.0, poll_before)
# 按统一规则排序(防止外部遗漏 sort)
# 这里不依赖外部 sort_reservations_callback:避免回调内部潜在阻塞/死锁导致主流程卡死。
try:
analyser._log_kv(
"预约",
"[预约] process_reservation_attend_window:开始队列排序",
reservations_count=len(reservations) if reservations else 0,
)
except Exception:
pass
# 超时检查
try:
if (time.time() - start_time) > total_timeout_s:
try:
analyser._log_kv(
"预约",
"[预约] process_reservation_attend_window:超时退出(排序前)",
total_timeout_seconds=round(total_timeout_s, 3),
)
except Exception:
pass
return False
except Exception:
pass
try:
_sort_reservations_inplace(reservations)
except Exception as e:
if _RESERVATION_ERROR_UTILS_AVAILABLE:
log_reservation_error(
analyser,
e,
format_reservation_context(reservations=reservations),
level="WARNING",
stage="队列排序",
)
else:
try:
analyser._log_kv(
"预约",
"[预约] process_reservation_attend_window:队列排序异常(忽略)",
error=str(e),
error_type=type(e).__name__,
)
except Exception:
pass
try:
analyser._log_kv(
"预约",
"[预约] process_reservation_attend_window:队列排序完成",
earliest_future_ts=(
int(float((reservations[0].get("future_ts") or 0.0)))
if reservations
else 0
),
)
except Exception:
pass
# 锁定期内:优先处理“锁定的预约”,避免被队头其它预约打断。
# 同时,如果锁定期对应的预约已不在队列(例如刚参与成功并移除),视为“锁定失效”,清除锁定期。
if focus_until > 0 and now_ts < focus_until:
locked_idx = None
try:
for i, item in enumerate(reservations):
try:
item_ft = float(item.get("future_ts") or 0.0)
except Exception:
continue
if item_ft <= 0:
continue
expected_focus_until = item_ft + max(0.0, poll_before)
if abs(focus_until - expected_focus_until) <= 5.0:
locked_idx = i
break
except Exception:
locked_idx = None
if locked_idx is None:
try:
analyser._log_kv(
"预约",
"[预约] 检测到锁定期已失效(锁定预约不在队列),清除锁定期",
focus_until=int(focus_until),
lock_period_remain_seconds=int(focus_until - now_ts),
reservations_count=len(reservations),
)
except Exception:
pass
try:
if reservation_focus_until_ts_ref:
reservation_focus_until_ts_ref[0] = 0.0
else:
reservation_focus_until_ts_ref.append(0.0)
except Exception:
pass
focus_until = 0.0
elif locked_idx != 0:
try:
locked_item = reservations.pop(locked_idx)
reservations.insert(0, locked_item)
analyser._log_kv(
"预约",
"[预约] 锁定期内固定处理锁定预约(忽略队头其他预约)",
focus_until=int(focus_until),
locked_future_ts=int(float(locked_item.get("future_ts") or 0.0)),
moved_from_index=int(locked_idx),
)
except Exception:
pass
# 超时检查
try:
if (time.time() - start_time) > total_timeout_s:
try:
analyser._log_kv(
"预约",
"[预约] process_reservation_attend_window:超时退出(排序后)",
total_timeout_seconds=round(total_timeout_s, 3),
)
except Exception:
pass
return False
except Exception:
pass
# 取队头(最早需要处理的一条;若在锁定期内已将锁定目标移动到队头,则这里即为锁定目标)
target = reservations[0]
try:
ft = float(target.get("future_ts") or 0.0)
except Exception:
ft = 0.0
try:
target_room_title = str(target.get("room_title") or "")
except Exception:
target_room_title = ""
try:
target_room_title_raw = str(target.get("room_title_raw") or "")
except Exception:
target_room_title_raw = ""
try:
target_content = str(target.get("content") or "")
except Exception:
target_content = ""
try:
target_value = float(target.get("prize_value_yuan") or 0.0)
except Exception:
target_value = 0.0
if pop_if_already_participated(
analyser,
reservations,
target,
ft,
write_state_callback,
_RESERVATION_ERROR_UTILS_AVAILABLE,
):
return False
log_target_snapshot(analyser, target, ft)
if pop_if_invalid_future_ts(
analyser,
reservations,
target,
ft,
write_state_callback,
_RESERVATION_ERROR_UTILS_AVAILABLE,
):
return False
# 仅在"即将开奖窗口"(包括已过一小段时间)内才触发回退
try:
join_ahead = float(
getattr(analyser, "high_value_fudai_join_ahead_seconds", 100) or 100
)
except Exception:
join_ahead = 100.0
# poll_before 已在函数前部统一计算
dynamic_ahead, est_back_times = compute_dynamic_ahead(
analyser,
target,
room_pos,
reservation_back_swipe_delay_s,
join_ahead,
)
# 添加详细的调试日志:记录锁定期状态和时间窗口检查结果
try:
from datetime import datetime
now_str = datetime.fromtimestamp(now_ts).strftime("%Y-%m-%d %H:%M:%S")
time_window_start_ts = ft - dynamic_ahead
time_window_start_str = (
datetime.fromtimestamp(time_window_start_ts).strftime("%Y-%m-%d %H:%M:%S")
if time_window_start_ts > 0
else "无效"
)
time_window_end_ts = ft + max(0.0, poll_before)
time_window_end_str = (
datetime.fromtimestamp(time_window_end_ts).strftime("%Y-%m-%d %H:%M:%S")
if time_window_end_ts > 0
else "无效"
)
ft_str = (
datetime.fromtimestamp(ft).strftime("%Y-%m-%d %H:%M:%S")
if ft > 0
else "无效"
)
analyser._log_kv(
"预约",
"[预约] process_reservation_attend_window 详细检查",
now_ts=int(now_ts),
now_str=now_str,
focus_until=int(focus_until) if focus_until > 0 else 0,
target_future_ts=int(ft),
target_future_str=ft_str,
dynamic_ahead=dynamic_ahead,
join_ahead=join_ahead,
poll_before=poll_before,
est_back_times=est_back_times,
time_window_start=int(time_window_start_ts),
time_window_start_str=time_window_start_str,
time_window_end=int(time_window_end_ts),
time_window_end_str=time_window_end_str,
remain_seconds_to_open=int(ft - now_ts) if ft > now_ts else 0,
remain_seconds_to_window=(
int(time_window_start_ts - now_ts)
if time_window_start_ts > now_ts
else 0
),
in_lock_period=bool(focus_until > 0 and now_ts < focus_until),
in_time_window=bool(now_ts >= time_window_start_ts),
passed_time_window=bool(now_ts > time_window_end_ts),
)
except Exception:
pass
# 优化锁定期检查:
# 1. 如果没有锁定期(focus_until = 0),直接允许检查时间窗口
# 2. 如果锁定期已过期(now_ts >= focus_until),允许检查时间窗口
# 3. 如果锁定期还没结束,但预约时间已经到了,检查是否是同一个预约
# - 如果是同一个预约,允许回退(通常已经在目标直播间了)
# - 如果不是同一个预约,不允许回退(需要等待当前预约完成)
# 4. 特殊情况:如果是队列满后立即参与模式(通过标志判断),允许检查时间窗口
# 先检查是否是队列满立即参与模式
is_queue_full_immediate_attend_check = False
try:
queue_full_waiting_check = bool(
getattr(analyser, "queue_full_waiting_at_earliest", False) or False
)
if queue_full_waiting_check:
is_queue_full_immediate_attend_check = True
except Exception:
pass
if (
focus_until > 0
and now_ts < focus_until
and abs(focus_until - now_ts) > 1.0
and not is_queue_full_immediate_attend_check
):
# 锁定期还没结束,检查是否是同一个预约(允许5秒误差)
expected_focus_until = ft + max(0.0, poll_before)
if abs(focus_until - expected_focus_until) > 5.0:
# 不是同一个预约,锁定期还没结束,不允许回退
try:
analyser._log_kv(
"预约",
"[预约] 锁定期未结束且不是当前预约,跳过回退",
focus_until=int(focus_until),
expected_focus_until=int(expected_focus_until),
target_future_ts=int(ft),
lock_period_remain_seconds=int(focus_until - now_ts),
)
except Exception:
pass
return False
# 是同一个预约,即使锁定期还没结束,如果时间窗口到了,也允许回退
# 但这里通常已经在目标直播间了,需要检查是否已经在目标位置
# 获取当前实际的 room_pos(可能已经被更新)
try:
current_room_pos_check = int(
getattr(analyser, "room_pos", room_pos) or room_pos
)
except Exception:
current_room_pos_check = int(room_pos)
# 计算位置差
try:
target_pos_check = int(target.get("pos_seen") or 0)
except Exception:
target_pos_check = 0
pos_diff_check = current_room_pos_check - target_pos_check
# 如果已经在目标位置(pos_diff == 0),说明已经在目标直播间,不需要再次回退
# 但是需要检查时间窗口是否到达,如果到达了,应该返回 True 表示需要参与
# 或者如果是队列满立即参与模式,直接返回 True
if pos_diff_check == 0:
# 检查是否是队列满立即参与模式
is_queue_full_immediate_attend_pos = False
try:
queue_full_waiting_pos = bool(
getattr(analyser, "queue_full_waiting_at_earliest", False) or False
)
if queue_full_waiting_pos:
is_queue_full_immediate_attend_pos = True
except Exception:
pass
# 检查时间窗口是否到达,或者是队列满立即参与模式
if is_queue_full_immediate_attend_pos or (
now_ts >= ft - dynamic_ahead and now_ts <= ft + max(0.0, poll_before)
):
# 时间窗口已到达或队列满立即参与模式,虽然已在目标位置,但需要参与,返回 True
try:
analyser._log_kv(
"预约",
"[预约] 锁定期未结束但是同一个预约,且已在目标位置,时间窗口已到达或队列满立即参与模式,需要参与",
focus_until=int(focus_until),
target_future_ts=int(ft),
current_room_pos=current_room_pos_check,
target_pos=target_pos_check,
now_ts=int(now_ts),
time_window_start=int(ft - dynamic_ahead),
time_window_end=int(ft + max(0.0, poll_before)),
is_queue_full_immediate_attend=is_queue_full_immediate_attend_pos,
)
except Exception:
pass
# 更新锁定期和待处理标志(如果不是队列满立即参与模式,才设置锁定期)
if not is_queue_full_immediate_attend_pos:
focus_until_new = ft + max(0.0, poll_before)
if reservation_focus_until_ts_ref:
reservation_focus_until_ts_ref[0] = focus_until_new
else:
reservation_focus_until_ts_ref.append(focus_until_new)
if reservation_after_action_pending_ref:
reservation_after_action_pending_ref[0] = True
else:
reservation_after_action_pending_ref.append(True)
try:
write_state_callback()
except Exception:
pass
return True
else:
# 时间窗口未到达,跳过
# 注意:如果已经在目标位置但时间窗口未到,不应该设置 reservation_after_action_pending
# 因为这会导致反复等待,应该清除这个标志,让主循环正常处理
try:
analyser._log_kv(
"预约",
"[预约] 锁定期未结束但是同一个预约,且已在目标位置,但时间窗口未到达,跳过回退并清除待处理标志",
focus_until=int(focus_until),
target_future_ts=int(ft),
current_room_pos=current_room_pos_check,
target_pos=target_pos_check,
now_ts=int(now_ts),
time_window_start=int(ft - dynamic_ahead),
time_window_end=int(ft + max(0.0, poll_before)),
)
except Exception:
pass
# 清除待处理标志,避免反复等待
if reservation_after_action_pending_ref:
reservation_after_action_pending_ref[0] = False
return False
# 如果不在目标位置,继续检查时间窗口
try:
analyser._log_kv(
"预约",
"[预约] 锁定期未结束但是同一个预约,继续检查时间窗口",
focus_until=int(focus_until),
target_future_ts=int(ft),
current_room_pos=current_room_pos_check,
target_pos=target_pos_check,
pos_diff=pos_diff_check,
)
except Exception:
pass
# 检查是否是队列满后立即参与的情况(使用标志判断,而不是锁定期)
is_queue_full_immediate_attend = False
try:
# 检查队列满等待标志
queue_full_waiting = bool(
getattr(analyser, "queue_full_waiting_at_earliest", False) or False
)
if queue_full_waiting:
is_queue_full_immediate_attend = True
try:
analyser._log_kv(
"预约",
"[预约] 检测到队列满后立即参与模式(通过标志判断),跳过时间窗口检查,直接参与",
queue_full_waiting=queue_full_waiting,
target_future_ts=int(ft),
)
except Exception:
pass
except Exception:
pass
if not is_queue_full_immediate_attend and now_ts < ft - dynamic_ahead:
# 还没到窗口(非队列满立即参与模式)
try:
from datetime import datetime
time_window_start_ts = ft - dynamic_ahead
time_window_start_str = (
datetime.fromtimestamp(time_window_start_ts).strftime(
"%Y-%m-%d %H:%M:%S"
)
if time_window_start_ts > 0
else "无效"
)
analyser._log_kv(
"预约",
"[预约] 时间窗口未到,跳过回退",
now_ts=int(now_ts),
now_str=datetime.fromtimestamp(now_ts).strftime("%Y-%m-%d %H:%M:%S"),
time_window_start=int(time_window_start_ts),
time_window_start_str=time_window_start_str,
remain_seconds=int((ft - dynamic_ahead) - now_ts),
target_future_ts=int(ft),
dynamic_ahead=dynamic_ahead,
)
except Exception:
pass
return False
if now_ts > ft + max(0.0, poll_before):
# 已明显错过开奖时间,交给统一清理逻辑
try:
analyser._log_kv(
"预约",
"[预约] 已明显错过开奖时间,清理过期预约",
future_ts=int(ft),
now_ts=int(now_ts),
poll_before=poll_before,
missed_seconds=int(now_ts - (ft + max(0.0, poll_before))),
)
except Exception:
pass
cleanup_expired_reservations(analyser, reservations, write_state_callback)
return False
# 进入预约参与窗口:执行回退动作
try:
analyser._log_kv(
"预约",
"[预约] 进入预约参与窗口,准备回退到目标直播间",
future_ts=int(ft),
now_ts=int(now_ts),
room_pos=int(room_pos),
queue_len=len(reservations),
dynamic_ahead=int(dynamic_ahead),
est_back_times=int(est_back_times),
remain_seconds_to_open=int(ft - now_ts),
time_window_start=int(ft - dynamic_ahead),
time_window_end=int(ft + max(0.0, poll_before)),
)
except Exception:
pass
# 获取当前实际的 room_pos(可能已经被更新)
try:
current_room_pos = int(getattr(analyser, "room_pos", room_pos) or room_pos)
except Exception:
current_room_pos = int(room_pos)
# 计算位置差
try:
target_pos = int(target.get("pos_seen") or 0)
except Exception:
target_pos = 0
pos_diff = current_room_pos - target_pos
# 调用上层提供的"按预约信息回退到目标直播间"的回调
try:
analyser._log_kv(
"预约",
"[预约] 准备执行回退到预约直播间",
target_pos_seen=target_pos,
current_room_pos=current_room_pos,
pos_diff=pos_diff,
)
except Exception:
pass
# 直接调用回退回调,不需要预先下滑
# 原因:
# 1. 回退前已经进行了阶段诊断,处理了弹窗和福袋详情页等异常状态
# 2. 如果已经在直播间,不需要下滑
# 3. 预先下滑会导致 room_pos 减1,影响后续的回退计算,导致少回退一个直播间
ok = False
try:
ok = bool(seek_reservation_room_callback(target))
except Exception as e:
if _RESERVATION_ERROR_UTILS_AVAILABLE:
log_reservation_error(
analyser,
e,
format_reservation_context(
item=target,
reservations=reservations,
current_room_pos=current_room_pos,
target_pos=target_pos,
pos_diff=pos_diff,
),
level="ERROR",
stage="执行回退操作",
)
else:
try:
analyser._log_kv(
"预约",
"[预约] 执行回退时发生异常",
error=str(e),
error_type=type(e).__name__,
)
except Exception:
pass
ok = False
if ok:
from douyin.reservation.reservation_logic.attend_window_verify import (
handle_back_verify,
)
_verify_result = handle_back_verify(
analyser=analyser,
target=target,
reservations=reservations,
room_pos=room_pos,
ft=ft,
poll_before=poll_before,
reservation_focus_until_ts_ref=reservation_focus_until_ts_ref,
reservation_after_action_pending_ref=reservation_after_action_pending_ref,
seek_reservation_room_callback=seek_reservation_room_callback,
write_state_callback=write_state_callback,
)
if _verify_result is not None:
return _verify_result
# 如果回退或校验失败,直接返回 False
if not ok:
try:
analyser._log_kv(
"预约",
"[预约] 回退或校验失败,保留队列以便后续重试或清理",
future_ts=int(ft),
now_ts=int(now_ts),
remain_seconds_to_open=int(ft - now_ts),
target_pos=int(target.get("pos_seen", 0)),
current_room_pos=int(room_pos),
)
except Exception:
pass
try:
write_state_callback()
except Exception:
pass
return False
mark_reservation_focus_and_log_success(
analyser=analyser,
ft=ft,
poll_before=poll_before,
now_ts=now_ts,
target_room_title=target_room_title,
target_room_title_raw=target_room_title_raw,
target_content=target_content,
target_value=target_value,
reservation_focus_until_ts_ref=reservation_focus_until_ts_ref,
reservation_after_action_pending_ref=reservation_after_action_pending_ref,
)
# 不在这里弹出队列,等待真正"参与完毕"后由上层统一处理
try:
write_state_callback()
except Exception:
pass
log_attend_window_result(
analyser=analyser,
start_time=start_time,
result="已触发回退",
ft=ft,
now_ts=now_ts,
)
return True
# 回退失败:记录日志,等待后续重试或清理
log_back_failed_keep_queue(
analyser=analyser,
ft=ft,
now_ts=now_ts,
target=target,
room_pos=room_pos,
)
try:
write_state_callback()
except Exception:
pass
log_attend_window_result(
analyser=analyser,
start_time=start_time,
result="未触发回退",
ft=ft,
now_ts=now_ts,
)
return False