360 lines
14 KiB
Python
360 lines
14 KiB
Python
"""Библиотека в памяти процесса и её заливка в БД.
|
||
|
||
В памяти живёт то, что читает голосовой контур и оценка; в БД — то, из чего
|
||
преподаватель выбирает сценарий и что переживает перезапуск.
|
||
"""
|
||
|
||
from collections.abc import Callable
|
||
from pathlib import Path
|
||
from uuid import uuid4
|
||
|
||
from sqlalchemy import select
|
||
from sqlalchemy.ext.asyncio import AsyncSession
|
||
|
||
from app.db.models import Scenario as ScenarioRow
|
||
from app.scenarios import editor
|
||
from app.scenarios.loader import load_library
|
||
from app.scenarios.schema import Scenario
|
||
|
||
_library: dict[str, Scenario] = {}
|
||
_demo_drafts: dict[str, ScenarioRow] = {}
|
||
_demo_archived: dict[str, Scenario] = {}
|
||
_demo_scenario_owners: dict[str, str] = {}
|
||
_demo_archived_owners: dict[str, str] = {}
|
||
BeforeCommit = Callable[[AsyncSession, ScenarioRow], None]
|
||
|
||
|
||
def reset_demo_drafts() -> None:
|
||
"""Черновики и архив demo-lite живут только в текущем процессе."""
|
||
_demo_drafts.clear()
|
||
_demo_archived.clear()
|
||
_demo_scenario_owners.clear()
|
||
_demo_archived_owners.clear()
|
||
|
||
|
||
def set_library(scenarios: list[Scenario]) -> None:
|
||
_library.clear()
|
||
_library.update({scenario.id: scenario for scenario in scenarios})
|
||
|
||
|
||
def get(scenario_id: str) -> Scenario | None:
|
||
return _library.get(scenario_id)
|
||
|
||
|
||
def all_scenarios() -> list[Scenario]:
|
||
return list(_library.values())
|
||
|
||
|
||
def publish(scenario: Scenario) -> None:
|
||
"""Сделать утверждённую версию доступной запуску занятия немедленно."""
|
||
_library[scenario.id] = scenario
|
||
|
||
|
||
def register_owned_scenario(scenario: Scenario, owner_login: str) -> None:
|
||
"""Обновить runtime-библиотеку после публикации модерируемого сценария."""
|
||
_library[scenario.id] = scenario
|
||
_demo_scenario_owners[scenario.id] = owner_login
|
||
|
||
|
||
def load_from_disk(root: Path) -> list[Scenario]:
|
||
scenarios = load_library(root)
|
||
set_library(scenarios)
|
||
return scenarios
|
||
|
||
|
||
async def seed(db: AsyncSession, scenarios: list[Scenario]) -> int:
|
||
"""Залить библиотеку в БД. Повторный запуск обновляет, а не дублирует."""
|
||
for scenario in scenarios:
|
||
row = await db.scalar(select(ScenarioRow).where(ScenarioRow.id == scenario.id))
|
||
payload = scenario.model_dump(mode="json")
|
||
if row is None:
|
||
row = ScenarioRow(id=scenario.id)
|
||
db.add(row)
|
||
row.title = scenario.title
|
||
row.incident_type = scenario.type.value
|
||
row.level = scenario.level.value
|
||
row.topics = scenario.topics
|
||
row.modes = scenario.modes
|
||
row.body = payload
|
||
row.owner_login = None
|
||
await db.commit()
|
||
return len(scenarios)
|
||
|
||
|
||
async def restore_published(db: AsyncSession) -> int:
|
||
"""После старта вернуть утверждённые преподавателем сценарии из БД.
|
||
|
||
Вызвать после ``load_from_disk``. Базовую библиотеку не перезаписываем:
|
||
её источником остаются проверенные YAML из репозитория.
|
||
"""
|
||
rows = await db.scalars(select(ScenarioRow).where(
|
||
ScenarioRow.status.in_(["published", "archived"])
|
||
))
|
||
delta = 0
|
||
for row in rows:
|
||
if row.status == "archived":
|
||
if row.owner_login:
|
||
_demo_scenario_owners.pop(row.id, None)
|
||
_demo_archived_owners[row.id] = row.owner_login
|
||
if _library.pop(row.id, None) is not None:
|
||
delta -= 1
|
||
continue
|
||
if row.owner_login:
|
||
_demo_scenario_owners[row.id] = row.owner_login
|
||
# Shipped YAML remains the canonical source for base cards, but a
|
||
# published instructor-owned row may have changed on another process.
|
||
already_loaded = row.id in _library
|
||
if already_loaded and row.owner_login is None:
|
||
continue
|
||
_library[row.id] = Scenario.model_validate(row.body)
|
||
if not already_loaded:
|
||
delta += 1
|
||
return delta
|
||
|
||
|
||
async def published_catalog(
|
||
db: AsyncSession, scenario_ids: list[str], owner_login: str | None,
|
||
) -> tuple[dict[str, Scenario], set[str]]:
|
||
"""Resolve startable scenarios from shared DB, including a peer's cache misses.
|
||
|
||
Process-local memory remains a fallback only for the shipped library. Any
|
||
database row is authoritative: archived/pending rows never fall back to a
|
||
stale in-memory copy, and instructor-owned rows stay private across nodes.
|
||
"""
|
||
ids = set(scenario_ids)
|
||
if not ids:
|
||
return {}, set()
|
||
rows = await db.scalars(select(ScenarioRow).where(ScenarioRow.id.in_(ids)))
|
||
by_id = {row.id: row for row in rows}
|
||
scenarios: dict[str, Scenario] = {}
|
||
hidden: set[str] = set()
|
||
for scenario_id, row in by_id.items():
|
||
if row.owner_login and row.owner_login != owner_login:
|
||
hidden.add(scenario_id)
|
||
continue
|
||
if row.status == "published":
|
||
scenario = Scenario.model_validate(row.body)
|
||
scenarios[scenario_id] = scenario
|
||
# Refresh a stale process-local version from the authoritative row.
|
||
_library[scenario_id] = scenario
|
||
for scenario_id in ids - by_id.keys():
|
||
scenario = _library.get(scenario_id)
|
||
# A process-local owner marker without a durable row is not publishable.
|
||
if scenario is not None and scenario_id not in _demo_scenario_owners:
|
||
scenarios[scenario_id] = scenario
|
||
return scenarios, hidden
|
||
|
||
|
||
async def owned_scenario_ids(db: AsyncSession | None, owner_login: str) -> set[str]:
|
||
"""IDs the current instructor may edit/archive; base and legacy rows are read-only."""
|
||
if db is None:
|
||
return {
|
||
scenario_id for scenario_id, owner in _demo_scenario_owners.items()
|
||
if owner == owner_login and scenario_id in _library
|
||
}
|
||
rows = await db.scalars(select(ScenarioRow.id).where(
|
||
ScenarioRow.owner_login == owner_login,
|
||
ScenarioRow.status == "published",
|
||
))
|
||
values = set(rows)
|
||
# Test doubles and alternate SQLAlchemy result wrappers may return rows
|
||
# for a scalar selection; normalize them without leaking owner data.
|
||
return {value if isinstance(value, str) else value.id for value in values}
|
||
|
||
|
||
async def scenario_ids_owned_by_other(db: AsyncSession | None, owner_login: str) -> set[str]:
|
||
"""Hide another instructor's private scenarios from this instructor's bank."""
|
||
if db is None:
|
||
return {
|
||
scenario_id for scenario_id, owner in _demo_scenario_owners.items()
|
||
if owner != owner_login
|
||
}
|
||
rows = await db.scalars(select(ScenarioRow.id).where(
|
||
ScenarioRow.owner_login.is_not(None),
|
||
ScenarioRow.owner_login != owner_login,
|
||
ScenarioRow.status == "published",
|
||
))
|
||
return {value if isinstance(value, str) else value.id for value in rows}
|
||
|
||
|
||
async def archive(
|
||
db: AsyncSession | None, scenario_id: str, *, owner_login: str | None = None,
|
||
before_commit: BeforeCommit | None = None,
|
||
) -> Scenario | None:
|
||
"""Скрыть опубликованный сценарий без удаления истории и внешних ключей."""
|
||
scenario = _library.get(scenario_id)
|
||
if scenario is None:
|
||
return None
|
||
if db is None:
|
||
owner = _demo_scenario_owners.get(scenario_id)
|
||
if owner_login is not None and owner != owner_login:
|
||
return None
|
||
_demo_archived[scenario_id] = scenario
|
||
if owner is not None:
|
||
_demo_archived_owners[scenario_id] = owner
|
||
_demo_scenario_owners.pop(scenario_id, None)
|
||
else:
|
||
row = await db.get(ScenarioRow, scenario_id)
|
||
if owner_login is not None and (row is None or row.owner_login != owner_login):
|
||
return None
|
||
if row is None:
|
||
row = ScenarioRow(
|
||
id=scenario.id,
|
||
title=scenario.title,
|
||
incident_type=scenario.type.value,
|
||
level=scenario.level.value,
|
||
topics=scenario.topics,
|
||
modes=scenario.modes,
|
||
body=scenario.model_dump(mode="json"),
|
||
)
|
||
db.add(row)
|
||
row.status = "archived"
|
||
if before_commit is not None:
|
||
before_commit(db, row)
|
||
await db.commit()
|
||
_library.pop(scenario_id, None)
|
||
return scenario
|
||
|
||
|
||
async def restore_archived(
|
||
db: AsyncSession | None, scenario_id: str, *, owner_login: str | None = None,
|
||
before_commit: BeforeCommit | None = None,
|
||
) -> Scenario | None:
|
||
"""Вернуть мягко удалённый сценарий в библиотеку назначения."""
|
||
if db is None:
|
||
owner = _demo_archived_owners.get(scenario_id)
|
||
if owner_login is not None and owner != owner_login:
|
||
return None
|
||
scenario = _demo_archived.pop(scenario_id, None)
|
||
if scenario is not None and owner is not None:
|
||
_demo_scenario_owners[scenario_id] = owner
|
||
_demo_archived_owners.pop(scenario_id, None)
|
||
else:
|
||
row = await db.get(ScenarioRow, scenario_id)
|
||
if (row is None or row.status != "archived"
|
||
or owner_login is not None and row.owner_login != owner_login):
|
||
return None
|
||
# В опубликованном body уже лежат вычисленные поля ground_truth (ЕКП,
|
||
# ДДС, список оповещения). Редакторская validate предназначена для
|
||
# черновика до вычисления и закономерно запрещает такие поля.
|
||
scenario = Scenario.model_validate(row.body)
|
||
row.status = "published"
|
||
if before_commit is not None:
|
||
before_commit(db, row)
|
||
await db.commit()
|
||
if scenario is None:
|
||
return None
|
||
publish(scenario)
|
||
return scenario
|
||
|
||
|
||
async def create_draft(
|
||
db: AsyncSession | None, *, source: Scenario, title: str | None = None,
|
||
proposal: dict | None = None, full_proposal: dict | None = None,
|
||
owner_login: str | None = None, before_commit: BeforeCommit | None = None,
|
||
) -> ScenarioRow:
|
||
if proposal is not None and full_proposal is not None:
|
||
raise ValueError("нельзя одновременно передать вариацию и полный сюжет")
|
||
prefix = "ai-full" if full_proposal is not None else "ai" if proposal is not None else "draft"
|
||
draft_id = f"{prefix}-{uuid4().hex}"
|
||
if full_proposal is not None:
|
||
from app.scenarios.generation import full_proposal_body
|
||
|
||
body = full_proposal_body(source, draft_id, full_proposal)
|
||
elif proposal is None:
|
||
body = editor.template_copy(source, draft_id, title)
|
||
else:
|
||
from app.scenarios.generation import proposal_body
|
||
|
||
body = proposal_body(source, draft_id, proposal)
|
||
row = ScenarioRow(
|
||
id=draft_id,
|
||
title=body["title"],
|
||
incident_type=body["type"],
|
||
level=body["level"],
|
||
topics=body["topics"],
|
||
modes=body["modes"],
|
||
status="draft",
|
||
owner_login=owner_login,
|
||
body=body,
|
||
)
|
||
if db is None:
|
||
_demo_drafts[row.id] = row
|
||
else:
|
||
db.add(row)
|
||
if before_commit is not None:
|
||
before_commit(db, row)
|
||
await db.commit()
|
||
return row
|
||
|
||
|
||
async def draft(
|
||
db: AsyncSession | None, scenario_id: str, *, owner_login: str | None = None
|
||
) -> ScenarioRow | None:
|
||
row = _demo_drafts.get(scenario_id) if db is None else await db.get(ScenarioRow, scenario_id)
|
||
if row is None or row.status != "draft":
|
||
return None
|
||
if owner_login is not None and row.owner_login != owner_login:
|
||
return None
|
||
return row
|
||
|
||
|
||
async def update_draft(
|
||
db: AsyncSession | None, row: ScenarioRow, patch: dict,
|
||
*, before_commit: BeforeCommit | None = None,
|
||
) -> ScenarioRow:
|
||
row.body = editor.merge_patch(row.body, patch)
|
||
row.title = str(row.body.get("title") or "")[:200]
|
||
row.manual_edit_pending = True
|
||
row.grammar_check_hash = None
|
||
if db is not None:
|
||
if before_commit is not None:
|
||
before_commit(db, row)
|
||
await db.commit()
|
||
return row
|
||
|
||
|
||
async def revise_draft(
|
||
db: AsyncSession | None, row: ScenarioRow, proposal: dict,
|
||
*, before_commit: BeforeCommit | None = None,
|
||
) -> ScenarioRow:
|
||
"""Заменить сюжетную версию того же черновика после комментария преподавателя."""
|
||
from app.scenarios.generation import proposal_body
|
||
|
||
source = editor.validate(row.body)
|
||
row.body = proposal_body(source, row.id, proposal)
|
||
row.title = row.body["title"]
|
||
row.incident_type = row.body["type"]
|
||
row.level = row.body["level"]
|
||
row.topics = row.body["topics"]
|
||
row.modes = row.body["modes"]
|
||
row.manual_edit_pending = False
|
||
row.grammar_check_hash = None
|
||
if db is not None:
|
||
if before_commit is not None:
|
||
before_commit(db, row)
|
||
await db.commit()
|
||
return row
|
||
|
||
|
||
async def approve_draft(
|
||
db: AsyncSession | None, row: ScenarioRow, *, before_commit: BeforeCommit | None = None,
|
||
) -> Scenario:
|
||
scenario = editor.validate(row.body)
|
||
row.title = scenario.title
|
||
row.incident_type = scenario.type.value
|
||
row.level = scenario.level.value
|
||
row.topics = scenario.topics
|
||
row.modes = scenario.modes
|
||
row.body = scenario.model_dump(mode="json")
|
||
row.status = "published"
|
||
if db is None:
|
||
_demo_drafts.pop(row.id, None)
|
||
if row.owner_login is not None:
|
||
_demo_scenario_owners[row.id] = row.owner_login
|
||
else:
|
||
if before_commit is not None:
|
||
before_commit(db, row)
|
||
await db.commit()
|
||
publish(scenario)
|
||
return scenario
|