astrbot_plugin_imagestudio/core/queue_manager.py

113 行
3.7 KiB
Python

"""In-memory generation queue primitives."""
from __future__ import annotations
from collections import deque
from dataclasses import dataclass, field
from datetime import datetime, timezone
from typing import Any
from uuid import uuid4
from core.fsm import task_transition
def _now() -> str:
return datetime.now(timezone.utc).isoformat()
@dataclass
class QueueItem:
task_id: str
payload: dict[str, Any]
status: str = "queued"
idempotency_key: str | None = None
attempts: int = 0
error_message: str | None = None
created_at: str = field(default_factory=_now)
updated_at: str = field(default_factory=_now)
def to_dict(self) -> dict[str, Any]:
return {
"task_id": self.task_id,
"payload": self.payload,
"status": self.status,
"idempotency_key": self.idempotency_key,
"attempts": self.attempts,
"error_message": self.error_message,
"created_at": self.created_at,
"updated_at": self.updated_at,
}
class QueueManager:
def __init__(self):
self._pending: deque[str] = deque()
self._items: dict[str, QueueItem] = {}
self._idempotency_index: dict[str, str] = {}
def enqueue(self, payload: dict[str, Any], *, idempotency_key: str | None = None) -> QueueItem:
if idempotency_key and idempotency_key in self._idempotency_index:
return self._items[self._idempotency_index[idempotency_key]]
item = QueueItem(
task_id=str(payload.get("task_id") or f"task_{uuid4().hex}"),
payload=dict(payload),
idempotency_key=idempotency_key,
)
self._items[item.task_id] = item
if idempotency_key:
self._idempotency_index[idempotency_key] = item.task_id
self._pending.append(item.task_id)
return item
def dequeue(self) -> QueueItem | None:
while self._pending:
task_id = self._pending.popleft()
item = self._items.get(task_id)
if item and item.status == "queued":
self._set_status(item, "running")
item.attempts += 1
return item
return None
def complete(self, task_id: str, result: dict[str, Any] | None = None) -> QueueItem:
item = self.get(task_id)
item.payload = {**item.payload, "result": result or {}}
self._set_status(item, "succeeded")
item.error_message = None
return item
def fail(self, task_id: str, error_message: str, *, dead_letter: bool = False) -> QueueItem:
item = self.get(task_id)
self._set_status(item, "failed")
item.error_message = error_message
if dead_letter:
self._set_status(item, "dead_letter")
return item
def retry(self, task_id: str) -> QueueItem:
item = self.get(task_id)
self._set_status(item, "queued")
item.error_message = None
if task_id not in self._pending:
self._pending.append(task_id)
return item
def get(self, task_id: str) -> QueueItem:
item = self._items.get(task_id)
if item is None:
raise KeyError(task_id)
return item
def summary(self) -> dict[str, int]:
counts = {"queued": 0, "running": 0, "succeeded": 0, "failed": 0, "dead_letter": 0}
for item in self._items.values():
counts[item.status] = counts.get(item.status, 0) + 1
return counts
def _set_status(self, item: QueueItem, status: str) -> None:
transition = task_transition(item.status, status)
if not transition.allowed:
raise ValueError(transition.reason)
item.status = transition.target
item.updated_at = _now()