astrbot_plugin_private_comp.../schedule_reconciler.py

162 行
6.4 KiB
Python

# -*- coding: utf-8 -*-
"""Deterministic plan/actual reconciliation for the local C3 agenda."""
from __future__ import annotations
from datetime import datetime, timedelta
import re
from typing import Any
try:
from .agenda_contracts import (
agenda_entry_from_activity,
agenda_entry_from_plan,
interval_overlaps_window,
normalize_observed_activity,
normalize_plan_item,
parse_datetime,
stable_id,
)
except ImportError:
from agenda_contracts import (
agenda_entry_from_activity,
agenda_entry_from_plan,
interval_overlaps_window,
normalize_observed_activity,
normalize_plan_item,
parse_datetime,
stable_id,
)
def _normalized_text(value: Any) -> str:
return re.sub(r"[^0-9a-z\u4e00-\u9fff]+", "", str(value or "").lower())
def _tokens(value: Any) -> set[str]:
text = _normalized_text(value)
if not text:
return set()
tokens = {text}
tokens.update(text[index:index + 2] for index in range(max(0, len(text) - 1)))
tokens.update(text[index:index + 3] for index in range(max(0, len(text) - 2)))
return {token for token in tokens if len(token) >= 2}
def _interval(item: dict[str, Any], now: datetime) -> tuple[datetime | None, datetime | None]:
try:
start = parse_datetime(item.get("start_at") or item.get("start"), default=now)
except Exception:
return None, None
try:
end = parse_datetime(item.get("end_at") or item.get("end"), default=start)
except Exception:
end = start
if end <= start:
end = start + timedelta(seconds=1)
return start, end
def _overlaps(plan: dict[str, Any], activity: dict[str, Any], now: datetime) -> bool:
ps, pe = _interval(plan, now)
a_s, a_e = _interval(activity, now)
return bool(ps and pe and a_s and a_e and ps < a_e and a_s < pe)
def _title_similarity(plan: dict[str, Any], activity: dict[str, Any]) -> float:
plan_text = _normalized_text(plan.get("title") or plan.get("activity"))
activity_text = _normalized_text(activity.get("title") or activity.get("summary"))
if not plan_text or not activity_text:
return 0.0
if plan_text in activity_text or activity_text in plan_text:
return 1.0
shared = _tokens(plan_text).intersection(_tokens(activity_text))
if not shared:
return 0.0
return len(shared) / max(1, len(_tokens(plan_text).union(_tokens(activity_text))))
def _same_source(plan: dict[str, Any], activity: dict[str, Any]) -> bool:
plan_id = str(plan.get("plan_id") or plan.get("event_id") or "").strip()
plan_refs = {str(ref) for ref in (plan.get("source_refs") or []) if str(ref)}
activity_refs = {str(ref) for ref in (activity.get("source_refs") or []) if str(ref)}
return bool((plan_id and plan_id in activity_refs) or plan_refs.intersection(activity_refs))
def _plan_is_past(plan: dict[str, Any], now: datetime) -> bool:
_start, end = _interval(plan, now)
return bool(end and end <= now)
def reconcile(
plans: list[dict[str, Any]],
activities: list[dict[str, Any]],
*,
now: datetime,
) -> dict[str, Any]:
normalized_plans: list[dict[str, Any]] = []
for raw in plans or []:
try:
normalized_plans.append(normalize_plan_item(raw, now=now))
except Exception:
continue
normalized_activities: list[dict[str, Any]] = []
for raw in activities or []:
try:
normalized_activities.append(normalize_observed_activity(raw, now=now))
except Exception:
continue
used_activity_ids: set[str] = set()
reconciled_plans: list[dict[str, Any]] = []
reconciliations: list[dict[str, Any]] = []
entries: list[dict[str, Any]] = []
matched: dict[str, list[str]] = {}
for plan in normalized_plans:
plan_id = str(plan.get("plan_id") or stable_id("plan", plan.get("title")))
exact = [activity for activity in normalized_activities if _same_source(plan, activity)]
overlap_candidates = [activity for activity in normalized_activities if _overlaps(plan, activity, now)]
similar = [activity for activity in overlap_candidates if _title_similarity(plan, activity) >= 0.18]
selected = exact or similar
plan_result = dict(plan)
if selected:
ids = [str(item.get("activity_id")) for item in selected]
matched[plan_id] = ids
used_activity_ids.update(ids)
all_completed = all(str(item.get("status")) == "completed" for item in selected)
plan_result["status"] = "completed" if all_completed else "active"
reason = "plan_id/source_refs matched" if exact else "time overlap and controlled title similarity"
plan_result["reconciliation_reason"] = reason
plan_result["reconciled_activity_ids"] = ids
reconciliation = {
"reconciliation_id": stable_id("reconciliation", plan_id, ids),
"plan_id": plan_id,
"status": plan_result["status"],
"source_kind": "reconciled",
"evidence_level": "L3" if any(item.get("evidence_level") in {"L3", "L4", "L5"} for item in selected) else "L2",
"source_refs": [plan_id, *ids],
"activity_ids": ids,
"reason": reason,
}
reconciliations.append(reconciliation)
entries.append(agenda_entry_from_plan(plan_result, reason=reason))
entries.extend(agenda_entry_from_activity(item, source_refs=[plan_id, *ids]) for item in selected)
else:
if plan_result.get("status") not in {"cancelled", "deferred"} and _plan_is_past(plan_result, now):
plan_result["status"] = "unknown"
plan_result["reconciliation_reason"] = "window ended without observed evidence"
entries.append(agenda_entry_from_plan(plan_result, reason=plan_result.get("reconciliation_reason", "")))
reconciled_plans.append(plan_result)
for activity in normalized_activities:
if str(activity.get("activity_id")) not in used_activity_ids:
entries.append(agenda_entry_from_activity(activity))
entries.sort(key=lambda item: (str(item.get("start_at") or ""), 0 if item.get("kind") == "observed" else 1))
return {
"plans": reconciled_plans,
"activities": normalized_activities,
"entries": entries,
"matched": matched,
"reconciliations": reconciliations,
}