初始化

This commit is contained in:
gozeros committed 2026-09-07 18:24:55 +08:00
1 parent 34474bd5fc
commit b638b541d0
3008 files changed
+837699

No files matched your search

@@ -0,0 +1,22 @@
"""Task-scoped situation-report persistence."""
from __future__ import annotations
from deerflow.persistence.task_reports.base import TaskReportStore
from deerflow.persistence.task_reports.memory import MemoryTaskReportStore
from deerflow.persistence.task_reports.model import TaskReportRow
from deerflow.persistence.task_reports.sql import TaskReportRepository
__all__ = [
"MemoryTaskReportStore",
"TaskReportRepository",
"TaskReportRow",
"TaskReportStore",
"make_task_report_store",
]
def make_task_report_store(session_factory):
if session_factory is None:
return MemoryTaskReportStore()
return TaskReportRepository(session_factory)
@@ -0,0 +1,47 @@
"""Persistence contract for task-scoped situation-report details.
Each task owns one shared report document. The document stores the exact
``data`` array consumed by the dashboard: each item's ``contentJson`` remains
a JSON *string* rather than being parsed into a database JSON column.
"""
from __future__ import annotations
from abc import ABC, abstractmethod
from typing import Any
class TaskReportStore(ABC):
"""Shared task-report document store (no user-level partitioning)."""
@abstractmethod
async def get_by_task(self, task_id: str) -> dict[str, Any] | None:
"""Return the stored document or ``None`` when the task has no report."""
raise NotImplementedError
@abstractmethod
async def create_by_task(
self,
task_id: str,
records: list[dict[str, Any]],
*,
updated_by: str | None = None,
) -> dict[str, Any] | None:
"""Create a document, returning ``None`` if that task already exists."""
raise NotImplementedError
@abstractmethod
async def update_by_task(
self,
task_id: str,
records: list[dict[str, Any]],
*,
updated_by: str | None = None,
) -> dict[str, Any] | None:
"""Replace a document's records, or return ``None`` when absent."""
raise NotImplementedError
@abstractmethod
async def delete_by_task(self, task_id: str) -> bool:
"""Delete a task's report document and return whether it existed."""
raise NotImplementedError
@@ -0,0 +1,56 @@
"""In-memory task-report store for deployments without a SQL database."""
from __future__ import annotations
from copy import deepcopy
from datetime import UTC, datetime
from typing import Any
from deerflow.persistence.task_reports.base import TaskReportStore
class MemoryTaskReportStore(TaskReportStore):
def __init__(self) -> None:
self._rows: dict[str, dict[str, Any]] = {}
async def get_by_task(self, task_id: str) -> dict[str, Any] | None:
row = self._rows.get(task_id)
return deepcopy(row) if row is not None else None
async def create_by_task(
self,
task_id: str,
records: list[dict[str, Any]],
*,
updated_by: str | None = None,
) -> dict[str, Any] | None:
if task_id in self._rows:
return None
now = datetime.now(UTC).isoformat()
row = {
"task_id": task_id,
"records": deepcopy(records),
"updated_by": updated_by,
"created_at": now,
"updated_at": now,
}
self._rows[task_id] = row
return deepcopy(row)
async def update_by_task(
self,
task_id: str,
records: list[dict[str, Any]],
*,
updated_by: str | None = None,
) -> dict[str, Any] | None:
row = self._rows.get(task_id)
if row is None:
return None
row["records"] = deepcopy(records)
row["updated_by"] = updated_by
row["updated_at"] = datetime.now(UTC).isoformat()
return deepcopy(row)
async def delete_by_task(self, task_id: str) -> bool:
return self._rows.pop(task_id, None) is not None
@@ -0,0 +1,33 @@
"""ORM model for task-scoped situation-report details."""
from __future__ import annotations
from datetime import UTC, datetime
from sqlalchemy import String
from sqlalchemy.orm import Mapped, mapped_column
from deerflow.persistence.base import Base
from deerflow.persistence.types import BeijingDateTime, PortableLongText
class TaskReportRow(Base):
"""One complete situation report document for one task id.
``records_json`` is serialized explicitly by the repository. Keeping it
as long text preserves every item exactly as the existing Consumer API
returns it, including the nested ``contentJson`` JSON string.
"""
__tablename__ = "task_reports"
task_id: Mapped[str] = mapped_column(String(128), primary_key=True)
records_json: Mapped[str] = mapped_column(PortableLongText, nullable=False, default="[]")
updated_by: Mapped[str | None] = mapped_column(String(64), nullable=True)
created_at: Mapped[datetime] = mapped_column(BeijingDateTime(), nullable=False, default=lambda: datetime.now(UTC))
updated_at: Mapped[datetime] = mapped_column(
BeijingDateTime(),
nullable=False,
default=lambda: datetime.now(UTC),
onupdate=lambda: datetime.now(UTC),
)
@@ -0,0 +1,96 @@
"""SQLAlchemy-backed task-report document store."""
from __future__ import annotations
import json
from datetime import UTC, datetime
from typing import Any
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
from deerflow.persistence.task_reports.base import TaskReportStore
from deerflow.persistence.task_reports.model import TaskReportRow
def _decode_records(raw: str) -> list[dict[str, Any]]:
try:
value = json.loads(raw)
except (TypeError, ValueError):
return []
return value if isinstance(value, list) else []
def _encode_records(records: list[dict[str, Any]]) -> str:
# ``contentJson`` is already a string in each record, so json.dumps keeps
# it escaped exactly as required by the existing frontend contract.
return json.dumps(records, ensure_ascii=False, separators=(",", ":"))
def _to_dict(row: TaskReportRow) -> dict[str, Any]:
return {
"task_id": row.task_id,
"records": _decode_records(row.records_json),
"updated_by": row.updated_by,
"created_at": row.created_at.isoformat() if isinstance(row.created_at, datetime) else row.created_at,
"updated_at": row.updated_at.isoformat() if isinstance(row.updated_at, datetime) else row.updated_at,
}
class TaskReportRepository(TaskReportStore):
def __init__(self, session_factory: async_sessionmaker[AsyncSession]) -> None:
self._sf = session_factory
async def get_by_task(self, task_id: str) -> dict[str, Any] | None:
async with self._sf() as session:
row = await session.get(TaskReportRow, task_id)
return _to_dict(row) if row is not None else None
async def create_by_task(
self,
task_id: str,
records: list[dict[str, Any]],
*,
updated_by: str | None = None,
) -> dict[str, Any] | None:
async with self._sf() as session:
if await session.get(TaskReportRow, task_id) is not None:
return None
now = datetime.now(UTC)
row = TaskReportRow(
task_id=task_id,
records_json=_encode_records(records),
updated_by=updated_by,
created_at=now,
updated_at=now,
)
session.add(row)
await session.commit()
await session.refresh(row)
return _to_dict(row)
async def update_by_task(
self,
task_id: str,
records: list[dict[str, Any]],
*,
updated_by: str | None = None,
) -> dict[str, Any] | None:
async with self._sf() as session:
row = await session.get(TaskReportRow, task_id)
if row is None:
return None
row.records_json = _encode_records(records)
row.updated_by = updated_by
row.updated_at = datetime.now(UTC)
await session.commit()
await session.refresh(row)
return _to_dict(row)
async def delete_by_task(self, task_id: str) -> bool:
async with self._sf() as session:
row = await session.get(TaskReportRow, task_id)
if row is None:
return False
await session.delete(row)
await session.commit()
return True