初始化

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,27 @@
"""Position-roundtable role configuration persistence.
This is deliberately separate from :mod:`deerflow.persistence.positions`.
The latter represents organisational positions and resource grants, while this
package describes the work views used inside the position-roundtable product.
"""
from __future__ import annotations
from deerflow.persistence.position_roles.base import PositionRoleStore
from deerflow.persistence.position_roles.memory import MemoryPositionRoleStore
from deerflow.persistence.position_roles.model import PositionRoleRow
from deerflow.persistence.position_roles.sql import PositionRoleRepository
__all__ = [
"MemoryPositionRoleStore",
"PositionRoleRepository",
"PositionRoleRow",
"PositionRoleStore",
"make_position_role_store",
]
def make_position_role_store(session_factory):
if session_factory is None:
return MemoryPositionRoleStore()
return PositionRoleRepository(session_factory)
@@ -0,0 +1,30 @@
"""Abstract storage for position-roundtable role configuration."""
from __future__ import annotations
from abc import ABC, abstractmethod
from typing import Any
class PositionRoleStore(ABC):
"""Global configuration shared by every position-roundtable session."""
@abstractmethod
async def list_roles(self) -> list[dict[str, Any]]:
"""Return roles in presentation order."""
raise NotImplementedError
@abstractmethod
async def replace_all(
self,
rows: list[dict[str, Any]],
*,
updated_by: str | None = None,
) -> list[dict[str, Any]]:
"""Atomically replace the editable role directory."""
raise NotImplementedError
@abstractmethod
async def ensure_seed(self, rows: list[dict[str, Any]]) -> list[dict[str, Any]]:
"""Insert only missing built-in roles, without overwriting edits."""
raise NotImplementedError
@@ -0,0 +1,45 @@
"""In-memory fallback for position-roundtable role configuration."""
from __future__ import annotations
from datetime import UTC, datetime
from typing import Any
from deerflow.persistence.position_roles.base import PositionRoleStore
def _normalize(row: dict[str, Any], updated_by: str | None = None) -> dict[str, Any]:
return {
"id": str(row["id"]),
"name": str(row.get("name") or ""),
"description": str(row.get("description") or ""),
"role_type": str(row.get("role_type") or "standard"),
"enabled": bool(row.get("enabled", True)),
"is_builtin": bool(row.get("is_builtin", False)),
"sort_order": int(row.get("sort_order", 0)),
"updated_by": updated_by,
"updated_at": datetime.now(UTC).isoformat(),
}
class MemoryPositionRoleStore(PositionRoleStore):
def __init__(self) -> None:
self._rows: dict[str, dict[str, Any]] = {}
async def list_roles(self) -> list[dict[str, Any]]:
return [dict(row) for row in sorted(self._rows.values(), key=lambda item: (item["sort_order"], item["id"]))]
async def replace_all(self, rows: list[dict[str, Any]], *, updated_by: str | None = None) -> list[dict[str, Any]]:
self._rows = {
str(row["id"]): _normalize(row, updated_by)
for row in rows
if row.get("id")
}
return await self.list_roles()
async def ensure_seed(self, rows: list[dict[str, Any]]) -> list[dict[str, Any]]:
for row in rows:
row_id = str(row.get("id") or "")
if row_id and row_id not in self._rows:
self._rows[row_id] = _normalize(row)
return await self.list_roles()
@@ -0,0 +1,37 @@
"""ORM model for configurable position-roundtable roles."""
from __future__ import annotations
from datetime import UTC, datetime
from sqlalchemy import Boolean, Integer, String
from sqlalchemy.orm import Mapped, mapped_column
from deerflow.persistence.base import Base
from deerflow.persistence.types import BeijingDateTime
class PositionRoleRow(Base):
"""A work-view role in the position-roundtable product.
``role_type`` is intentionally small and stable: ``standard`` denotes a
normal business-chain position; ``intent`` denotes the single special
position responsible for initial intent identification and closing-agent
entry. It is a configuration concern, not an organisation/RBAC position.
"""
__tablename__ = "position_roles"
id: Mapped[str] = mapped_column(String(128), primary_key=True)
name: Mapped[str] = mapped_column(String(128), unique=True, index=True)
description: Mapped[str] = mapped_column(String(512), default="")
role_type: Mapped[str] = mapped_column(String(32), default="standard", index=True)
enabled: Mapped[bool] = mapped_column(Boolean, default=True)
is_builtin: Mapped[bool] = mapped_column(Boolean, default=False, server_default="0")
sort_order: Mapped[int] = mapped_column(Integer, default=0)
updated_by: Mapped[str | None] = mapped_column(String(64))
updated_at: Mapped[datetime] = mapped_column(
BeijingDateTime(),
default=lambda: datetime.now(UTC),
onupdate=lambda: datetime.now(UTC),
)
@@ -0,0 +1,66 @@
"""SQLAlchemy storage for position-roundtable role configuration."""
from __future__ import annotations
from datetime import datetime
from typing import Any
from sqlalchemy import delete, select
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
from deerflow.persistence.position_roles.base import PositionRoleStore
from deerflow.persistence.position_roles.model import PositionRoleRow
def _to_dict(row: PositionRoleRow) -> dict[str, Any]:
data = row.to_dict()
if isinstance(data.get("updated_at"), datetime):
data["updated_at"] = data["updated_at"].isoformat()
return data
def _row_from(data: dict[str, Any], updated_by: str | None = None) -> PositionRoleRow:
return PositionRoleRow(
id=str(data["id"]),
name=str(data.get("name") or ""),
description=str(data.get("description") or ""),
role_type=str(data.get("role_type") or "standard"),
enabled=bool(data.get("enabled", True)),
is_builtin=bool(data.get("is_builtin", False)),
sort_order=int(data.get("sort_order", 0)),
updated_by=updated_by,
)
class PositionRoleRepository(PositionRoleStore):
def __init__(self, session_factory: async_sessionmaker[AsyncSession]) -> None:
self._sf = session_factory
async def list_roles(self) -> list[dict[str, Any]]:
statement = select(PositionRoleRow).order_by(PositionRoleRow.sort_order.asc(), PositionRoleRow.id.asc())
async with self._sf() as session:
rows = (await session.execute(statement)).scalars()
return [_to_dict(row) for row in rows]
async def replace_all(self, rows: list[dict[str, Any]], *, updated_by: str | None = None) -> list[dict[str, Any]]:
# Keep the final occurrence of duplicate ids so malformed UI payloads
# cannot violate the primary-key constraint.
by_id = {str(row["id"]): row for row in rows if row.get("id")}
async with self._sf() as session:
await session.execute(delete(PositionRoleRow))
created = [_row_from(row, updated_by) for row in by_id.values()]
session.add_all(created)
await session.commit()
for row in created:
await session.refresh(row)
return [_to_dict(row) for row in sorted(created, key=lambda item: (item.sort_order, item.id))]
async def ensure_seed(self, rows: list[dict[str, Any]]) -> list[dict[str, Any]]:
"""Idempotently insert new built-ins without changing operator edits."""
async with self._sf() as session:
existing_ids = set((await session.execute(select(PositionRoleRow.id))).scalars())
inserts = [_row_from(row) for row in rows if row.get("id") and str(row["id"]) not in existing_ids]
if inserts:
session.add_all(inserts)
await session.commit()
return await self.list_roles()