代码提交

This commit is contained in:
董宏凯 committed 2026-07-15 16:13:03 +08:00
1 parent 27e6b0b23e
commit d7ad0624b7
36 files changed
+2194 -287

No files matched your search

@@ -69,6 +69,8 @@ from deerflow.persistence.scheduled_tasks.model import (
)
from deerflow.persistence.skills.model import SkillDisplayAdapterRow, SkillFavoriteRow, SkillRow
from deerflow.persistence.task_buttons.model import TaskButtonRow
from deerflow.persistence.taskcop_tasks.model import TaskCopTaskRow
from deerflow.persistence.task_reports.model import TaskReportRow
from deerflow.persistence.tags.model import TagAssignmentRow, TagRow
from deerflow.persistence.thread_meta.model import ThreadMetaRow
from deerflow.persistence.embed_sessions.model import EmbedSessionRow
@@ -129,6 +131,8 @@ __all__ = [
"TagAssignmentRow",
"TagRow",
"TaskButtonRow",
"TaskCopTaskRow",
"TaskReportRow",
"EmbedSessionRow",
"ThreadMetaRow",
"ThreadShareRow",
@@ -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
@@ -0,0 +1,22 @@
"""TaskCOP situation-overview compatibility task persistence."""
from __future__ import annotations
from deerflow.persistence.taskcop_tasks.base import TaskCopTaskStore
from deerflow.persistence.taskcop_tasks.memory import MemoryTaskCopTaskStore
from deerflow.persistence.taskcop_tasks.model import TaskCopTaskRow
from deerflow.persistence.taskcop_tasks.sql import TaskCopTaskRepository
__all__ = [
"MemoryTaskCopTaskStore",
"TaskCopTaskRepository",
"TaskCopTaskRow",
"TaskCopTaskStore",
"make_taskcop_task_store",
]
def make_taskcop_task_store(session_factory):
if session_factory is None:
return MemoryTaskCopTaskStore()
return TaskCopTaskRepository(session_factory)
@@ -0,0 +1,60 @@
"""Persistence contract for the temporary TaskCOP task bridge.
The legacy situation-overview frontend distinguishes the global task list from
"my tasks". Task data is shared, while ``created_by`` is retained for the
per-user filter and as an audit field.
"""
from __future__ import annotations
from abc import ABC, abstractmethod
from datetime import datetime
from typing import Any
TASK_STATUS_ANALYSIS_COMPLETED = 25
class TaskCopTaskStore(ABC):
@abstractmethod
async def create_task(self, data: dict[str, Any]) -> dict[str, Any]:
"""Persist one task and return its legacy-compatible record."""
raise NotImplementedError
@abstractmethod
async def upsert_task(self, data: dict[str, Any]) -> tuple[dict[str, Any], bool]:
"""Create or completely replace one task identified by ``data['id']``.
Returns the legacy-compatible record and whether a new row was created.
"""
raise NotImplementedError
@abstractmethod
async def list_tasks(
self,
*,
created_by: str | None = None,
keyword: str = "",
task_direction: str | None = None,
task_statuses: set[int] | None = None,
start_time: datetime | None = None,
end_time: datetime | None = None,
page_num: int = 1,
page_size: int = 10,
) -> tuple[int, list[dict[str, Any]]]:
"""Return ``(total, records)`` using TaskCOP list semantics."""
raise NotImplementedError
@abstractmethod
async def get_task(self, task_id: str) -> dict[str, Any] | None:
"""Return a legacy-compatible task record, or ``None`` when absent."""
raise NotImplementedError
@abstractmethod
async def delete_task(self, task_id: str) -> bool:
"""Delete one task and return whether it existed."""
raise NotImplementedError
@abstractmethod
async def mark_analysis_completed(self, task_id: str) -> bool:
"""Move an existing task to the completed-analysis status (25)."""
raise NotImplementedError
@@ -0,0 +1,151 @@
"""In-memory TaskCOP task store for memory-mode deployments and tests."""
from __future__ import annotations
from datetime import UTC, datetime
from typing import Any
from deerflow.persistence.taskcop_tasks.base import TASK_STATUS_ANALYSIS_COMPLETED, TaskCopTaskStore
def _as_legacy(row: dict[str, Any]) -> dict[str, Any]:
def iso(value: datetime | None) -> str | None:
return value.isoformat() if value else None
return {
"id": row["id"],
"taskId": row["id"],
"taskName": row["task_name"],
"taskContent": row["overview"],
"overview": row["overview"],
"taskDirection": row["task_direction"],
"taskLevel": row["task_level"],
"taskStatus": row["task_status"],
"trendSucc": row["task_status"] >= TASK_STATUS_ANALYSIS_COMPLETED,
"taskType": row["task_type"],
"taskSuperiorFlag": row["task_superior_flag"],
"pTaskId": row.get("parent_task_id"),
"issuingDept": row["issuing_dept"],
"taskNo": row["task_no"],
"taskStartDate": iso(row.get("task_start_date")),
"taskEndDate": iso(row.get("task_end_date")),
"sourceType": 0,
"ifCreateTask": 0,
"sumAll": 0,
"endCount": 0,
"createTime": iso(row["create_time"]),
"updateTime": iso(row["update_time"]),
}
class MemoryTaskCopTaskStore(TaskCopTaskStore):
def __init__(self) -> None:
self._rows: dict[str, dict[str, Any]] = {}
async def create_task(self, data: dict[str, Any]) -> dict[str, Any]:
now = datetime.now(UTC)
task_id = str(data.get("id") or self._next_task_id())
row = {
"id": task_id,
"task_name": str(data["task_name"]),
"overview": str(data.get("overview") or ""),
"task_level": str(data.get("task_level") or "1"),
"task_direction": str(data.get("task_direction") or "W方向"),
"task_status": int(data.get("task_status", 0)),
"task_type": int(data.get("task_type", 1)),
"task_superior_flag": int(data.get("task_superior_flag", 0)),
"parent_task_id": data.get("parent_task_id") or None,
"issuing_dept": str(data.get("issuing_dept") or ""),
"task_no": str(data.get("task_no") or ""),
"created_by": str(data.get("created_by") or "default"),
"task_start_date": data.get("task_start_date"),
"task_end_date": data.get("task_end_date"),
"create_time": now,
"update_time": now,
}
self._rows[row["id"]] = row
return _as_legacy(row)
async def upsert_task(self, data: dict[str, Any]) -> tuple[dict[str, Any], bool]:
"""Import a task with a caller-provided id, replacing any existing row."""
task_id = str(data["id"])
previous = self._rows.get(task_id)
now = datetime.now(UTC)
row = {
"id": task_id,
"task_name": str(data["task_name"]),
"overview": str(data.get("overview") or ""),
"task_level": str(data.get("task_level") or "1"),
"task_direction": str(data.get("task_direction") or "W方向"),
"task_status": int(data.get("task_status", 0)),
"task_type": int(data.get("task_type", 1)),
"task_superior_flag": int(data.get("task_superior_flag", 0)),
"parent_task_id": data.get("parent_task_id") or None,
"issuing_dept": str(data.get("issuing_dept") or ""),
"task_no": str(data.get("task_no") or ""),
"created_by": str(data.get("created_by") or "default"),
"task_start_date": data.get("task_start_date"),
"task_end_date": data.get("task_end_date"),
"create_time": previous["create_time"] if previous is not None else now,
"update_time": now,
}
self._rows[task_id] = row
return _as_legacy(row), previous is None
def _next_task_id(self) -> str:
"""Return the next four-digit TaskCOP id, ignoring legacy UUID rows."""
numeric_ids = (int(task_id) for task_id in self._rows if task_id.isdecimal())
return f"{max(numeric_ids, default=0) + 1:04d}"
async def list_tasks(
self,
*,
created_by: str | None = None,
keyword: str = "",
task_direction: str | None = None,
task_statuses: set[int] | None = None,
start_time: datetime | None = None,
end_time: datetime | None = None,
page_num: int = 1,
page_size: int = 10,
) -> tuple[int, list[dict[str, Any]]]:
needle = keyword.strip().casefold()
rows = list(self._rows.values())
if created_by is not None:
rows = [row for row in rows if row["created_by"] == created_by]
if needle:
rows = [
row
for row in rows
if needle in row["task_name"].casefold()
or needle in row["overview"].casefold()
or needle in row["task_no"].casefold()
]
if task_direction:
rows = [row for row in rows if row["task_direction"] == task_direction]
if task_statuses:
rows = [row for row in rows if row["task_status"] in task_statuses]
if start_time:
rows = [row for row in rows if row["create_time"] >= start_time]
if end_time:
rows = [row for row in rows if row["create_time"] <= end_time]
rows.sort(key=lambda row: row["create_time"], reverse=True)
total = len(rows)
offset = max(page_num - 1, 0) * page_size
return total, [_as_legacy(row) for row in rows[offset : offset + page_size]]
async def get_task(self, task_id: str) -> dict[str, Any] | None:
row = self._rows.get(task_id)
return _as_legacy(row) if row is not None else None
async def delete_task(self, task_id: str) -> bool:
return self._rows.pop(task_id, None) is not None
async def mark_analysis_completed(self, task_id: str) -> bool:
row = self._rows.get(task_id)
if row is None:
return False
if row["task_status"] < TASK_STATUS_ANALYSIS_COMPLETED:
row["task_status"] = TASK_STATUS_ANALYSIS_COMPLETED
row["update_time"] = datetime.now(UTC)
return True
@@ -0,0 +1,41 @@
"""ORM model for TaskCOP compatibility tasks."""
from __future__ import annotations
from datetime import UTC, datetime
from sqlalchemy import Integer, String
from sqlalchemy.orm import Mapped, mapped_column
from deerflow.persistence.base import Base
from deerflow.persistence.types import BeijingDateTime, PortableLongText
class TaskCopTaskRow(Base):
"""A task created from the legacy situation-overview screen."""
__tablename__ = "taskcop_tasks"
id: Mapped[str] = mapped_column(String(64), primary_key=True)
task_name: Mapped[str] = mapped_column(String(512), nullable=False, index=True)
overview: Mapped[str] = mapped_column(PortableLongText, nullable=False, default="")
task_level: Mapped[str] = mapped_column(String(32), nullable=False, default="1")
task_direction: Mapped[str] = mapped_column(String(64), nullable=False, default="W方向", index=True)
task_status: Mapped[int] = mapped_column(Integer, nullable=False, default=0, index=True)
task_type: Mapped[int] = mapped_column(Integer, nullable=False, default=1)
task_superior_flag: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
parent_task_id: Mapped[str | None] = mapped_column(String(64), nullable=True, index=True)
issuing_dept: Mapped[str] = mapped_column(String(255), nullable=False, default="")
task_no: Mapped[str] = mapped_column(String(255), nullable=False, default="")
created_by: Mapped[str] = mapped_column(String(64), nullable=False, default="default", index=True)
task_start_date: Mapped[datetime | None] = mapped_column(BeijingDateTime(), nullable=True)
task_end_date: Mapped[datetime | None] = mapped_column(BeijingDateTime(), nullable=True)
create_time: Mapped[datetime] = mapped_column(
BeijingDateTime(), nullable=False, default=lambda: datetime.now(UTC), index=True
)
update_time: Mapped[datetime] = mapped_column(
BeijingDateTime(),
nullable=False,
default=lambda: datetime.now(UTC),
onupdate=lambda: datetime.now(UTC),
)
@@ -0,0 +1,182 @@
"""SQLAlchemy-backed TaskCOP compatibility task store."""
from __future__ import annotations
from datetime import datetime
from typing import Any
from sqlalchemy import func, or_, select
from sqlalchemy.exc import IntegrityError
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
from deerflow.persistence.taskcop_tasks.base import TASK_STATUS_ANALYSIS_COMPLETED, TaskCopTaskStore
from deerflow.persistence.taskcop_tasks.model import TaskCopTaskRow
def _as_legacy(row: TaskCopTaskRow) -> dict[str, Any]:
return {
"id": row.id,
"taskId": row.id,
"taskName": row.task_name,
"taskContent": row.overview,
"overview": row.overview,
"taskDirection": row.task_direction,
"taskLevel": row.task_level,
"taskStatus": row.task_status,
"trendSucc": row.task_status >= TASK_STATUS_ANALYSIS_COMPLETED,
"taskType": row.task_type,
"taskSuperiorFlag": row.task_superior_flag,
"pTaskId": row.parent_task_id,
"issuingDept": row.issuing_dept,
"taskNo": row.task_no,
"taskStartDate": row.task_start_date.isoformat() if row.task_start_date else None,
"taskEndDate": row.task_end_date.isoformat() if row.task_end_date else None,
"sourceType": 0,
"ifCreateTask": 0,
"sumAll": 0,
"endCount": 0,
"createTime": row.create_time.isoformat(),
"updateTime": row.update_time.isoformat(),
}
class TaskCopTaskRepository(TaskCopTaskStore):
def __init__(self, session_factory: async_sessionmaker[AsyncSession]) -> None:
self._sf = session_factory
async def create_task(self, data: dict[str, Any]) -> dict[str, Any]:
for _ in range(10):
try:
return await self._create_task_once(data)
except IntegrityError:
if data.get("id") is not None:
raise
raise RuntimeError("Failed to allocate a TaskCOP task id after multiple attempts")
async def _create_task_once(self, data: dict[str, Any]) -> dict[str, Any]:
task_id = str(data.get("id") or await self._next_task_id())
row = TaskCopTaskRow(
id=task_id,
task_name=str(data["task_name"]),
overview=str(data.get("overview") or ""),
task_level=str(data.get("task_level") or "1"),
task_direction=str(data.get("task_direction") or "W方向"),
task_status=int(data.get("task_status", 0)),
task_type=int(data.get("task_type", 1)),
task_superior_flag=int(data.get("task_superior_flag", 0)),
parent_task_id=data.get("parent_task_id") or None,
issuing_dept=str(data.get("issuing_dept") or ""),
task_no=str(data.get("task_no") or ""),
created_by=str(data.get("created_by") or "default"),
task_start_date=data.get("task_start_date"),
task_end_date=data.get("task_end_date"),
)
async with self._sf() as session:
session.add(row)
await session.commit()
await session.refresh(row)
return _as_legacy(row)
async def upsert_task(self, data: dict[str, Any]) -> tuple[dict[str, Any], bool]:
"""Import a caller-supplied task id, fully replacing an existing row."""
task_id = str(data["id"])
async with self._sf() as session:
row = await session.get(TaskCopTaskRow, task_id)
created = row is None
if row is None:
row = TaskCopTaskRow(id=task_id, task_name=str(data["task_name"]))
session.add(row)
row.task_name = str(data["task_name"])
row.overview = str(data.get("overview") or "")
row.task_level = str(data.get("task_level") or "1")
row.task_direction = str(data.get("task_direction") or "W方向")
row.task_status = int(data.get("task_status", 0))
row.task_type = int(data.get("task_type", 1))
row.task_superior_flag = int(data.get("task_superior_flag", 0))
row.parent_task_id = data.get("parent_task_id") or None
row.issuing_dept = str(data.get("issuing_dept") or "")
row.task_no = str(data.get("task_no") or "")
row.created_by = str(data.get("created_by") or "default")
row.task_start_date = data.get("task_start_date")
row.task_end_date = data.get("task_end_date")
await session.commit()
await session.refresh(row)
return _as_legacy(row), created
async def _next_task_id(self) -> str:
"""Return the next four-digit id, skipping historical UUID task rows."""
async with self._sf() as session:
task_ids = (await session.scalars(select(TaskCopTaskRow.id))).all()
numeric_ids = (int(task_id) for task_id in task_ids if task_id.isdecimal())
return f"{max(numeric_ids, default=0) + 1:04d}"
async def list_tasks(
self,
*,
created_by: str | None = None,
keyword: str = "",
task_direction: str | None = None,
task_statuses: set[int] | None = None,
start_time: datetime | None = None,
end_time: datetime | None = None,
page_num: int = 1,
page_size: int = 10,
) -> tuple[int, list[dict[str, Any]]]:
filters = []
if created_by is not None:
filters.append(TaskCopTaskRow.created_by == created_by)
if keyword.strip():
pattern = f"%{keyword.strip()}%"
filters.append(
or_(
TaskCopTaskRow.task_name.ilike(pattern),
TaskCopTaskRow.overview.ilike(pattern),
TaskCopTaskRow.task_no.ilike(pattern),
)
)
if task_direction:
filters.append(TaskCopTaskRow.task_direction == task_direction)
if task_statuses:
filters.append(TaskCopTaskRow.task_status.in_(task_statuses))
if start_time:
filters.append(TaskCopTaskRow.create_time >= start_time)
if end_time:
filters.append(TaskCopTaskRow.create_time <= end_time)
offset = max(page_num - 1, 0) * page_size
async with self._sf() as session:
total = await session.scalar(select(func.count()).select_from(TaskCopTaskRow).where(*filters))
stmt = (
select(TaskCopTaskRow)
.where(*filters)
.order_by(TaskCopTaskRow.create_time.desc())
.offset(offset)
.limit(page_size)
)
result = await session.execute(stmt)
return int(total or 0), [_as_legacy(row) for row in result.scalars()]
async def get_task(self, task_id: str) -> dict[str, Any] | None:
async with self._sf() as session:
row = await session.get(TaskCopTaskRow, task_id)
return _as_legacy(row) if row is not None else None
async def delete_task(self, task_id: str) -> bool:
async with self._sf() as session:
row = await session.get(TaskCopTaskRow, task_id)
if row is None:
return False
await session.delete(row)
await session.commit()
return True
async def mark_analysis_completed(self, task_id: str) -> bool:
async with self._sf() as session:
row = await session.get(TaskCopTaskRow, task_id)
if row is None:
return False
if row.task_status < TASK_STATUS_ANALYSIS_COMPLETED:
row.task_status = TASK_STATUS_ANALYSIS_COMPLETED
await session.commit()
return True