astrbot_plugin_moviepilot/notification_service.py

173 行
6.3 KiB
Python

此文件含有模棱两可的 Unicode 字符

此文件含有可能会与其他字符混淆的 Unicode 字符。 如果您是想特意这样的,可以安全地忽略该警告。 使用 Escape 按钮显示他们。

"""MoviePilot notification polling and fixed AstrBot targets."""
from __future__ import annotations
import asyncio
import hashlib
import json
import time
from collections.abc import Awaitable, Callable, Mapping
from pathlib import Path
from typing import Any
try:
from .moviepilot_client import MoviePilotClient
from .platform_compat import target_from_config
except ImportError:
from moviepilot_client import MoviePilotClient
from platform_compat import target_from_config
NotificationSender = Callable[[str, str], Awaitable[None]]
class NotificationPoller:
"""Poll MoviePilot notification history with a persistent cursor."""
def __init__(
self,
config: Mapping[str, Any],
state_path: str | Path,
sender: NotificationSender,
*,
clock: Callable[[], float] = time.time,
) -> None:
self._config = config
self._state_path = Path(state_path)
self._sender = sender
self._clock = clock
self._client: MoviePilotClient | None = None
self._task: asyncio.Task | None = None
self._cursor: int | None = self._load_cursor()
self._initialized = self._cursor is not None
def _get_client(self) -> MoviePilotClient:
if self._client is None:
self._client = MoviePilotClient(
str(self._config.get("moviepilot_url", "")),
str(self._config.get("moviepilot_api_token", "")),
timeout=float(self._config.get("moviepilot_timeout", 20)),
retries=int(self._config.get("moviepilot_retries", 2)),
retry_backoff=float(self._config.get("moviepilot_retry_backoff", 0.5)),
)
return self._client
def _load_cursor(self) -> int | None:
try:
payload = json.loads(self._state_path.read_text(encoding="utf-8"))
except (OSError, ValueError):
return None
value = payload.get("cursor") if isinstance(payload, dict) else None
try:
return int(value) if value is not None else None
except (TypeError, ValueError):
return None
def _save_cursor(self) -> None:
self._state_path.parent.mkdir(parents=True, exist_ok=True)
self._state_path.write_text(
json.dumps({"cursor": self._cursor}, ensure_ascii=False, indent=2) + "\n",
encoding="utf-8",
)
async def list_recent(self, *, count: int = 10) -> list[dict[str, Any]]:
response = await self._get_client().get(
"/api/v1/message/notification", params={"page": 1, "count": count}
)
if not isinstance(response.data, list):
return []
return [item for item in response.data if isinstance(item, dict)]
async def poll_once(self) -> list[dict[str, Any]]:
response = await self._get_client().get(
"/api/v1/message/notification", params={"page": 1, "count": 50}
)
notifications = [
item for item in response.data if isinstance(item, dict)
] if isinstance(response.data, list) else []
identified = [(self._notification_id(item), item) for item in notifications]
identified = [(item_id, item) for item_id, item in identified if item_id is not None]
identified.sort(key=lambda pair: pair[0])
if not identified:
return []
newest = identified[-1][0]
if not self._initialized:
self._cursor = newest
self._initialized = True
self._save_cursor()
return []
pending = [item for item_id, item in identified if item_id > (self._cursor or 0)]
self._cursor = newest
self._save_cursor()
targets = fixed_notification_targets(self._config)
for item in pending:
text = format_notification(item)
for target in targets:
await self._sender(target, text)
return pending
def start(self) -> None:
if self._task is None or self._task.done():
self._task = asyncio.create_task(self._run())
async def _run(self) -> None:
interval = max(int(self._config.get("notification_poll_interval", 60)), 15)
while True:
try:
await self.poll_once()
except asyncio.CancelledError:
raise
except Exception:
await asyncio.sleep(min(interval * 2, 300))
else:
await asyncio.sleep(interval)
async def close(self) -> None:
if self._task is not None:
self._task.cancel()
try:
await self._task
except asyncio.CancelledError:
pass
self._task = None
if self._client is not None:
await self._client.close()
self._client = None
@staticmethod
def _notification_id(item: Mapping[str, Any]) -> int | None:
value = item.get("id")
try:
return int(value) if value is not None else None
except (TypeError, ValueError):
return None
def fixed_notification_targets(config: Mapping[str, Any]) -> list[str]:
"""Build configured AstrBot unified message origins."""
platform_id = str(config.get("push_platform_id", "aiocqhttp")).strip()
targets: list[str] = []
group_id = str(config.get("push_group_id", "")).strip()
private_user_id = str(config.get("push_private_user_id", "")).strip()
group_target = target_from_config(platform_id, group_id=group_id)
private_target = target_from_config(platform_id, user_id=private_user_id)
if group_target:
targets.append(group_target.unified_msg_origin)
if private_target:
targets.append(private_target.unified_msg_origin)
return targets
def format_notification(item: Mapping[str, Any]) -> str:
title = item.get("title") or "MoviePilot 通知"
text = item.get("text") or item.get("message") or ""
link = item.get("link")
digest_source = json.dumps(dict(item), ensure_ascii=False, sort_keys=True)
digest = hashlib.sha1(digest_source.encode("utf-8")).hexdigest()[:8]
lines = [f"【{title}】", str(text) if text else ""]
if link:
lines.append(f"详情:{link}")
lines.append(f"通知 ID:{item.get('id', digest)}")
return "\n".join(line for line in lines if line)