402 行
18 KiB
Python
402 行
18 KiB
Python
|
|
# -*- coding: utf-8 -*-
|
|||
|
|
from __future__ import annotations
|
|||
|
|
|
|||
|
|
import asyncio
|
|||
|
|
import random
|
|||
|
|
import re
|
|||
|
|
from typing import Any
|
|||
|
|
|
|||
|
|
from astrbot.api import logger
|
|||
|
|
|
|||
|
|
from .helpers import _safe_float, _safe_int, _single_line
|
|||
|
|
|
|||
|
|
|
|||
|
|
class BusyReplyGateMixin:
|
|||
|
|
"""Delay passive replies and reschedule proactive messages while Bot is busy."""
|
|||
|
|
|
|||
|
|
_BUSY_ACTIVITY_PATTERN = re.compile(
|
|||
|
|
r"上课|课堂|听课|自习|学习|复习|预习|写作业|做作业|赶作业|做题|考试|测验|"
|
|||
|
|
r"开会|会议|工作|办公|值班|实习|训练|排练|实验|赶稿|写稿|编程|写代码|"
|
|||
|
|
r"处理(?:事情|任务|工作)|专注|集中精神|忙(?:着|碌|工作|学习)|通勤|赶路"
|
|||
|
|
)
|
|||
|
|
_BUSY_ACTIVITY_EXCLUSION_PATTERN = re.compile(
|
|||
|
|
r"睡觉|睡眠|午睡|午休|补觉|休息|发呆|摸鱼|放松|吃饭|用餐|散步|刷视频|"
|
|||
|
|
r"看番|打游戏|玩游戏|聊天|自由时间|准备睡|洗漱|刚醒|起床"
|
|||
|
|
)
|
|||
|
|
_BUSY_URGENT_PATTERN = re.compile(
|
|||
|
|
r"救命|出事|紧急|急事|报警|医院|受伤|流血|疼得|不舒服|呼吸困难|"
|
|||
|
|
r"害怕|崩溃|自杀|不想活|马上回|立刻回|快回|现在就回|十万火急"
|
|||
|
|
)
|
|||
|
|
_BUSY_PROACTIVE_EXEMPT_SOURCES = {
|
|||
|
|
"timer",
|
|||
|
|
"troubleshooting",
|
|||
|
|
"simulation",
|
|||
|
|
"memo_note",
|
|||
|
|
"environment_change",
|
|||
|
|
}
|
|||
|
|
_BUSY_PROACTIVE_EXEMPT_REASONS = {
|
|||
|
|
"timer",
|
|||
|
|
"memo_note_reminder",
|
|||
|
|
"environment_change",
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
def _busy_reply_private_scope(self, event: Any) -> str:
|
|||
|
|
umo = _single_line(getattr(event, "unified_msg_origin", ""), 160)
|
|||
|
|
if umo:
|
|||
|
|
return umo
|
|||
|
|
try:
|
|||
|
|
sender_id = _single_line(event.get_sender_id(), 80)
|
|||
|
|
except Exception:
|
|||
|
|
sender_id = ""
|
|||
|
|
return f"private:{sender_id}" if sender_id else ""
|
|||
|
|
|
|||
|
|
def _busy_reply_note_inbound_event(self, event: Any) -> int:
|
|||
|
|
"""Give each meaningful private inbound event a monotonic session token."""
|
|||
|
|
if not bool(getattr(self, "enable_busy_reply_gate", False)):
|
|||
|
|
return 0
|
|||
|
|
if bool(getattr(event, "_private_companion_busy_reply_inbound_token", 0)):
|
|||
|
|
return _safe_int(getattr(event, "_private_companion_busy_reply_inbound_token", 0), 0, 0)
|
|||
|
|
try:
|
|||
|
|
if not bool(event.is_private_chat()):
|
|||
|
|
return 0
|
|||
|
|
except Exception:
|
|||
|
|
umo = str(getattr(event, "unified_msg_origin", "") or "")
|
|||
|
|
if ":FriendMessage:" not in umo:
|
|||
|
|
return 0
|
|||
|
|
text = str(getattr(event, "message_str", "") or "").strip()
|
|||
|
|
message_obj = getattr(event, "message_obj", None)
|
|||
|
|
components = list(getattr(message_obj, "message", []) or []) if message_obj is not None else []
|
|||
|
|
if not text and not components:
|
|||
|
|
return 0
|
|||
|
|
sender_getter = getattr(self, "_event_sender_id", None)
|
|||
|
|
self_getter = getattr(self, "_event_self_id", None)
|
|||
|
|
try:
|
|||
|
|
sender_id = _single_line(sender_getter(event), 80) if callable(sender_getter) else ""
|
|||
|
|
self_id = _single_line(self_getter(event), 80) if callable(self_getter) else ""
|
|||
|
|
except Exception:
|
|||
|
|
sender_id = self_id = ""
|
|||
|
|
if sender_id and self_id and sender_id == self_id:
|
|||
|
|
return 0
|
|||
|
|
scope = self._busy_reply_private_scope(event)
|
|||
|
|
if not scope:
|
|||
|
|
return 0
|
|||
|
|
sequence = _safe_int(getattr(self, "_busy_reply_inbound_sequence", 0), 0, 0) + 1
|
|||
|
|
self._busy_reply_inbound_sequence = sequence
|
|||
|
|
versions = getattr(self, "_busy_reply_latest_inbound_tokens", None)
|
|||
|
|
if not isinstance(versions, dict):
|
|||
|
|
versions = {}
|
|||
|
|
self._busy_reply_latest_inbound_tokens = versions
|
|||
|
|
versions[scope] = sequence
|
|||
|
|
while len(versions) > 2000:
|
|||
|
|
versions.pop(next(iter(versions)), None)
|
|||
|
|
try:
|
|||
|
|
setattr(event, "_private_companion_busy_reply_inbound_scope", scope)
|
|||
|
|
setattr(event, "_private_companion_busy_reply_inbound_token", sequence)
|
|||
|
|
except Exception:
|
|||
|
|
pass
|
|||
|
|
return sequence
|
|||
|
|
|
|||
|
|
def _busy_reply_event_is_superseded(self, event: Any) -> bool:
|
|||
|
|
scope = _single_line(getattr(event, "_private_companion_busy_reply_inbound_scope", ""), 160)
|
|||
|
|
token = _safe_int(getattr(event, "_private_companion_busy_reply_inbound_token", 0), 0, 0)
|
|||
|
|
versions = getattr(self, "_busy_reply_latest_inbound_tokens", None)
|
|||
|
|
return bool(scope and token > 0 and isinstance(versions, dict) and _safe_int(versions.get(scope), 0, 0) != token)
|
|||
|
|
|
|||
|
|
@staticmethod
|
|||
|
|
def _busy_reply_stop_superseded_event(event: Any) -> None:
|
|||
|
|
try:
|
|||
|
|
setattr(event, "_private_companion_busy_reply_superseded", True)
|
|||
|
|
except Exception:
|
|||
|
|
pass
|
|||
|
|
stopper = getattr(event, "stop_event", None)
|
|||
|
|
if callable(stopper):
|
|||
|
|
try:
|
|||
|
|
stopper()
|
|||
|
|
except Exception:
|
|||
|
|
pass
|
|||
|
|
|
|||
|
|
def _busy_reply_presence_status(self, item: dict[str, Any]) -> tuple[str, str]:
|
|||
|
|
key = _single_line(item.get("key"), 80)
|
|||
|
|
enhanced = self.data.get("detail_enhanced_segments") if isinstance(getattr(self, "data", None), dict) else None
|
|||
|
|
detail = enhanced.get(key) if key and isinstance(enhanced, dict) else None
|
|||
|
|
status = detail.get("presence_status") if isinstance(detail, dict) else None
|
|||
|
|
if not isinstance(status, dict):
|
|||
|
|
return "", ""
|
|||
|
|
mode = _single_line(status.get("mode") or status.get("status"), 24).lower()
|
|||
|
|
label = _single_line(
|
|||
|
|
status.get("custom_text")
|
|||
|
|
or status.get("wording")
|
|||
|
|
or status.get("text")
|
|||
|
|
or status.get("label"),
|
|||
|
|
40,
|
|||
|
|
)
|
|||
|
|
return mode, label
|
|||
|
|
|
|||
|
|
def _busy_reply_item_is_busy(self, item: dict[str, Any] | None) -> tuple[bool, str]:
|
|||
|
|
if not isinstance(item, dict):
|
|||
|
|
return False, "no_current_schedule"
|
|||
|
|
lifecycle_normalizer = getattr(self, "_normalize_schedule_lifecycle_status", None)
|
|||
|
|
lifecycle = (
|
|||
|
|
lifecycle_normalizer(item.get("lifecycle_status"))
|
|||
|
|
if callable(lifecycle_normalizer)
|
|||
|
|
else _single_line(item.get("lifecycle_status"), 24).lower()
|
|||
|
|
)
|
|||
|
|
if lifecycle in {"cancelled", "completed", "skipped"}:
|
|||
|
|
return False, f"lifecycle:{lifecycle}"
|
|||
|
|
sleepy_checker = getattr(self, "_is_sleepy_plan_item", None)
|
|||
|
|
if callable(sleepy_checker):
|
|||
|
|
try:
|
|||
|
|
if sleepy_checker(item):
|
|||
|
|
return False, "sleep_schedule"
|
|||
|
|
except Exception:
|
|||
|
|
pass
|
|||
|
|
mode, label = self._busy_reply_presence_status(item)
|
|||
|
|
if mode in {"busy", "忙碌"}:
|
|||
|
|
return True, "presence:busy"
|
|||
|
|
if mode in {"custom", "自定义", "自定义状态"} and re.search(r"忙|专注|上课|学习|工作|开会", label):
|
|||
|
|
return True, f"presence:{label}"
|
|||
|
|
activity = _single_line(item.get("activity"), 220)
|
|||
|
|
mood = _single_line(item.get("mood"), 60)
|
|||
|
|
text = f"{activity} {mood}".strip()
|
|||
|
|
if not text:
|
|||
|
|
return False, "empty_schedule"
|
|||
|
|
if self._BUSY_ACTIVITY_EXCLUSION_PATTERN.search(text):
|
|||
|
|
return False, "leisure_or_rest_schedule"
|
|||
|
|
if self._BUSY_ACTIVITY_PATTERN.search(text):
|
|||
|
|
return True, "schedule_keyword"
|
|||
|
|
return False, "schedule_not_busy"
|
|||
|
|
|
|||
|
|
def _busy_reply_item_end_at(self, plan: dict[str, Any], current_item: dict[str, Any]) -> float:
|
|||
|
|
items = plan.get("items") if isinstance(plan.get("items"), list) else []
|
|||
|
|
if not items:
|
|||
|
|
return 0.0
|
|||
|
|
starts_getter = getattr(self, "_normalized_plan_item_starts", None)
|
|||
|
|
current_minutes_getter = getattr(self, "_effective_plan_now_minutes", None)
|
|||
|
|
end_getter = getattr(self, "_plan_item_end_minutes", None)
|
|||
|
|
if not all(callable(item) for item in (starts_getter, current_minutes_getter, end_getter)):
|
|||
|
|
return 0.0
|
|||
|
|
try:
|
|||
|
|
starts = starts_getter(items)
|
|||
|
|
current_minutes = current_minutes_getter(str(plan.get("date") or ""))
|
|||
|
|
except Exception:
|
|||
|
|
return 0.0
|
|||
|
|
if current_minutes is None:
|
|||
|
|
return 0.0
|
|||
|
|
selected_index = -1
|
|||
|
|
for index, item in enumerate(items):
|
|||
|
|
if item is current_item:
|
|||
|
|
selected_index = index
|
|||
|
|
break
|
|||
|
|
if selected_index < 0:
|
|||
|
|
current_key = _single_line(current_item.get("key") or current_item.get("id"), 80)
|
|||
|
|
if current_key:
|
|||
|
|
selected_index = next(
|
|||
|
|
(
|
|||
|
|
index
|
|||
|
|
for index, item in enumerate(items)
|
|||
|
|
if isinstance(item, dict)
|
|||
|
|
and _single_line(item.get("key") or item.get("id"), 80) == current_key
|
|||
|
|
),
|
|||
|
|
-1,
|
|||
|
|
)
|
|||
|
|
if selected_index < 0 or selected_index >= len(starts):
|
|||
|
|
return 0.0
|
|||
|
|
start_minutes = starts[selected_index]
|
|||
|
|
if start_minutes is None:
|
|||
|
|
return 0.0
|
|||
|
|
next_start = next((value for value in starts[selected_index + 1 :] if value is not None), None)
|
|||
|
|
try:
|
|||
|
|
end_minutes = end_getter(start_minutes, current_item, next_start=next_start)
|
|||
|
|
except Exception:
|
|||
|
|
return 0.0
|
|||
|
|
remaining_seconds = max(0, int(end_minutes - current_minutes) * 60)
|
|||
|
|
if remaining_seconds <= 0:
|
|||
|
|
return 0.0
|
|||
|
|
now_getter = getattr(self, "_environment_now", None)
|
|||
|
|
try:
|
|||
|
|
now_ts = float(now_getter().timestamp()) if callable(now_getter) else 0.0
|
|||
|
|
except Exception:
|
|||
|
|
now_ts = 0.0
|
|||
|
|
return now_ts + remaining_seconds if now_ts > 0 else 0.0
|
|||
|
|
|
|||
|
|
def _busy_reply_context(self) -> dict[str, Any]:
|
|||
|
|
if not bool(getattr(self, "enable_busy_reply_gate", False)):
|
|||
|
|
return {"busy": False, "reason": "disabled", "until": 0.0, "schedule": ""}
|
|||
|
|
data = getattr(self, "data", None)
|
|||
|
|
plan = data.get("daily_plan") if isinstance(data, dict) and isinstance(data.get("daily_plan"), dict) else {}
|
|||
|
|
current_getter = getattr(self, "_get_current_plan_item", None)
|
|||
|
|
try:
|
|||
|
|
current_item = current_getter(plan) if callable(current_getter) else None
|
|||
|
|
except Exception:
|
|||
|
|
current_item = None
|
|||
|
|
busy, reason = self._busy_reply_item_is_busy(current_item)
|
|||
|
|
formatter = getattr(self, "_format_plan_item_for_prompt", None)
|
|||
|
|
try:
|
|||
|
|
schedule = formatter(current_item) if busy and callable(formatter) else ""
|
|||
|
|
except Exception:
|
|||
|
|
schedule = ""
|
|||
|
|
until = self._busy_reply_item_end_at(plan, current_item) if busy and isinstance(current_item, dict) else 0.0
|
|||
|
|
return {
|
|||
|
|
"busy": busy,
|
|||
|
|
"reason": reason,
|
|||
|
|
"until": until,
|
|||
|
|
"schedule": _single_line(schedule, 220),
|
|||
|
|
"item": current_item if isinstance(current_item, dict) else None,
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
@classmethod
|
|||
|
|
def _busy_reply_bypass_reason(cls, text: Any) -> str:
|
|||
|
|
compact = re.sub(r"\s+", "", str(text or ""))
|
|||
|
|
if not compact:
|
|||
|
|
return ""
|
|||
|
|
if cls._BUSY_URGENT_PATTERN.search(compact):
|
|||
|
|
return "urgent_or_safety"
|
|||
|
|
if re.match(r"^[!!//]", compact):
|
|||
|
|
return "command"
|
|||
|
|
if re.search(r"^(?:陪伴|私聊陪伴).{0,8}(?:设置|配置|开启|关闭|启用|停用|检查|修复|诊断|状态)", compact):
|
|||
|
|
return "management_command"
|
|||
|
|
return ""
|
|||
|
|
|
|||
|
|
async def _apply_busy_reply_gate_delay(self, event: Any, *, is_private_chat: bool) -> tuple[float, str]:
|
|||
|
|
if not bool(getattr(self, "enable_busy_reply_gate", False)):
|
|||
|
|
return 0.0, "disabled"
|
|||
|
|
if bool(getattr(event, "_private_companion_busy_reply_delay_applied", False)):
|
|||
|
|
return 0.0, "already_applied"
|
|||
|
|
try:
|
|||
|
|
setattr(event, "_private_companion_busy_reply_delay_applied", True)
|
|||
|
|
except Exception:
|
|||
|
|
pass
|
|||
|
|
if is_private_chat:
|
|||
|
|
self._busy_reply_note_inbound_event(event)
|
|||
|
|
if self._busy_reply_event_is_superseded(event):
|
|||
|
|
self._busy_reply_stop_superseded_event(event)
|
|||
|
|
return 0.0, "superseded_by_newer_private_message"
|
|||
|
|
context = self._busy_reply_context()
|
|||
|
|
if not bool(context.get("busy")):
|
|||
|
|
return 0.0, str(context.get("reason") or "not_busy")
|
|||
|
|
bypass = self._busy_reply_bypass_reason(getattr(event, "message_str", ""))
|
|||
|
|
if bypass:
|
|||
|
|
return 0.0, f"bypass:{bypass}"
|
|||
|
|
minimum = _safe_int(getattr(self, "busy_reply_min_delay_seconds", 60), 60, 0)
|
|||
|
|
maximum = _safe_int(getattr(self, "busy_reply_max_delay_seconds", 300), 300, 0)
|
|||
|
|
minimum = min(900, minimum)
|
|||
|
|
maximum = min(900, maximum)
|
|||
|
|
if maximum < minimum:
|
|||
|
|
minimum, maximum = maximum, minimum
|
|||
|
|
if not is_private_chat:
|
|||
|
|
minimum = min(minimum, 12)
|
|||
|
|
maximum = min(maximum, 12)
|
|||
|
|
delay = random.uniform(minimum, maximum) if maximum > minimum else float(minimum)
|
|||
|
|
if delay <= 0:
|
|||
|
|
return 0.0, "zero_delay"
|
|||
|
|
try:
|
|||
|
|
setattr(event, "private_companion_busy_reply_delay_seconds", delay)
|
|||
|
|
setattr(event, "private_companion_busy_reply_schedule", context.get("schedule") or "")
|
|||
|
|
setattr(event, "private_companion_busy_reply_until", _safe_float(context.get("until"), 0.0))
|
|||
|
|
except Exception:
|
|||
|
|
pass
|
|||
|
|
logger.info(
|
|||
|
|
"[PrivateCompanion] 繁忙回复闸门延迟本轮被动回复: session=%s delay=%.1fs private=%s schedule=%s",
|
|||
|
|
_single_line(getattr(event, "unified_msg_origin", ""), 120) or "unknown",
|
|||
|
|
delay,
|
|||
|
|
is_private_chat,
|
|||
|
|
_single_line(context.get("schedule"), 140) or context.get("reason"),
|
|||
|
|
)
|
|||
|
|
await asyncio.sleep(delay)
|
|||
|
|
if is_private_chat and self._busy_reply_event_is_superseded(event):
|
|||
|
|
self._busy_reply_stop_superseded_event(event)
|
|||
|
|
logger.info(
|
|||
|
|
"[PrivateCompanion] 繁忙等待期间收到更新私聊,已取消陈旧回复: session=%s delay=%.1fs text=%s",
|
|||
|
|
_single_line(getattr(event, "unified_msg_origin", ""), 120) or "unknown",
|
|||
|
|
delay,
|
|||
|
|
_single_line(getattr(event, "message_str", ""), 100),
|
|||
|
|
)
|
|||
|
|
return delay, "superseded_by_newer_private_message"
|
|||
|
|
return delay, str(context.get("reason") or "busy")
|
|||
|
|
|
|||
|
|
def _busy_reply_proactive_block_until(
|
|||
|
|
self,
|
|||
|
|
user: dict[str, Any] | None,
|
|||
|
|
*,
|
|||
|
|
now: float,
|
|||
|
|
reason: Any = "",
|
|||
|
|
source: Any = "",
|
|||
|
|
) -> float:
|
|||
|
|
normalized_reason = _single_line(reason, 48).lower()
|
|||
|
|
normalized_source = _single_line(source, 48).lower()
|
|||
|
|
if normalized_source in self._BUSY_PROACTIVE_EXEMPT_SOURCES:
|
|||
|
|
return 0.0
|
|||
|
|
if normalized_reason in self._BUSY_PROACTIVE_EXEMPT_REASONS:
|
|||
|
|
return 0.0
|
|||
|
|
external_until = self._external_realtime_activity_block_until(user, now=now)
|
|||
|
|
if external_until > now:
|
|||
|
|
return external_until
|
|||
|
|
if not bool(getattr(self, "enable_busy_reply_gate", False)):
|
|||
|
|
return 0.0
|
|||
|
|
context = self._busy_reply_context()
|
|||
|
|
if not bool(context.get("busy")):
|
|||
|
|
return 0.0
|
|||
|
|
until = _safe_float(context.get("until"), 0.0)
|
|||
|
|
if until <= now:
|
|||
|
|
until = now + 15 * 60
|
|||
|
|
buffer_minutes = _safe_int(
|
|||
|
|
getattr(self, "busy_reply_proactive_resume_buffer_minutes", 10),
|
|||
|
|
10,
|
|||
|
|
0,
|
|||
|
|
)
|
|||
|
|
return until + min(120, buffer_minutes) * 60
|
|||
|
|
|
|||
|
|
def _external_realtime_activity_block_until(
|
|||
|
|
self,
|
|||
|
|
user: dict[str, Any] | None,
|
|||
|
|
*,
|
|||
|
|
now: float,
|
|||
|
|
) -> float:
|
|||
|
|
"""Pause unrelated proactive messages while another companion surface is live."""
|
|||
|
|
registry = getattr(self, "_external_realtime_activities", None)
|
|||
|
|
if not isinstance(registry, dict):
|
|||
|
|
return 0.0
|
|||
|
|
expired = [
|
|||
|
|
key
|
|||
|
|
for key, item in registry.items()
|
|||
|
|
if not isinstance(item, dict) or _safe_float(item.get("expires_at"), 0.0) <= now
|
|||
|
|
]
|
|||
|
|
for key in expired:
|
|||
|
|
registry.pop(key, None)
|
|||
|
|
user_id = _single_line((user or {}).get("user_id"), 80) if isinstance(user, dict) else ""
|
|||
|
|
active_until = 0.0
|
|||
|
|
for item in registry.values():
|
|||
|
|
if not isinstance(item, dict):
|
|||
|
|
continue
|
|||
|
|
activity_user_id = _single_line(item.get("user_id"), 80)
|
|||
|
|
if user_id and activity_user_id and activity_user_id != user_id:
|
|||
|
|
continue
|
|||
|
|
active_until = max(active_until, _safe_float(item.get("expires_at"), 0.0))
|
|||
|
|
return active_until
|
|||
|
|
|
|||
|
|
def _defer_proactive_for_busy(self, user: dict[str, Any], *, now: float, until: float) -> bool:
|
|||
|
|
if not isinstance(user, dict) or until <= now:
|
|||
|
|
return False
|
|||
|
|
current = _safe_float(user.get("next_proactive_at"), 0.0)
|
|||
|
|
if current > until:
|
|||
|
|
return False
|
|||
|
|
base = current if current > 0 else now
|
|||
|
|
shift = max(0.0, until - base)
|
|||
|
|
user["next_proactive_at"] = until
|
|||
|
|
for key in (
|
|||
|
|
"planned_proactive_window_start_at",
|
|||
|
|
"planned_proactive_preferred_at",
|
|||
|
|
"planned_proactive_best_until_at",
|
|||
|
|
"planned_proactive_expire_at",
|
|||
|
|
):
|
|||
|
|
value = _safe_float(user.get(key), 0.0)
|
|||
|
|
if value > 0:
|
|||
|
|
user[key] = value + shift
|
|||
|
|
if _safe_float(user.get("planned_proactive_window_start_at"), 0.0) <= 0:
|
|||
|
|
user["planned_proactive_window_start_at"] = until
|
|||
|
|
user["planned_proactive_best_until_at"] = until + 45 * 60
|
|||
|
|
user["planned_proactive_expire_at"] = until + 90 * 60
|
|||
|
|
user["busy_reply_deferred_until"] = until
|
|||
|
|
user["busy_reply_deferred_at"] = now
|
|||
|
|
return True
|