Merge origin/dev into feat/rag-clinical-guidelines
CI / ruff · pytest (pull_request) Successful in 2m9s
CI / ruff · pytest (pull_request) Successful in 2m9s
Conflict in app/api/routes.py: /demo/personas keeps the dev version (demo console, DB patients with scenarios); the patient app gets its own /patient/demo-personas (synthetic ЕМИАС accounts). Anonymous sign-in now always creates a doctor-less pseudonymous profile, since the dialog API of #12 serves known profiles only. Refs #77 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Claude Opus 5.5
@@ -0,0 +1,89 @@
|
||||
"""Demo-console helpers (#12, ADR-005): scripted personas, reset, connect links, outbox access.
|
||||
|
||||
Synthetic data only. Scenario files live in `data/synthetic/<slug>.jsonl` (#18); a patient is a scripted persona
|
||||
when the transliterated first word of the display name equals the slug ("Андрей С." → `andrey.jsonl`).
|
||||
"""
|
||||
|
||||
import inspect
|
||||
import logging
|
||||
from importlib import import_module, util
|
||||
from pathlib import Path
|
||||
|
||||
from app.config import get_settings
|
||||
from app.integrations.base import MemoryOutbox, Outbox, integrations
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
SEED_MODULE = "scripts.seed_demo"
|
||||
CONSOLE_PATH = "/console"
|
||||
|
||||
_TRANSLIT = {
|
||||
"а": "a", "б": "b", "в": "v", "г": "g", "д": "d", "е": "e", "ё": "e", "ж": "zh", "з": "z", "и": "i",
|
||||
"й": "y", "к": "k", "л": "l", "м": "m", "н": "n", "о": "o", "п": "p", "р": "r", "с": "s", "т": "t",
|
||||
"у": "u", "ф": "f", "х": "kh", "ц": "ts", "ч": "ch", "ш": "sh", "щ": "shch", "ъ": "", "ы": "y", "ь": "",
|
||||
"э": "e", "ю": "yu", "я": "ya",
|
||||
} # fmt: skip
|
||||
|
||||
|
||||
def persona_slug(display_name: str) -> str:
|
||||
first = (display_name.split() or [""])[0].lower()
|
||||
return "".join(_TRANSLIT.get(ch, ch if ch.isascii() and ch.isalnum() else "") for ch in first)
|
||||
|
||||
|
||||
def scenario_files(data_dir: Path | None = None) -> dict[str, str]:
|
||||
"""slug → scenario path relative to the project root, e.g. {"andrey": "data/synthetic/andrey.jsonl"}."""
|
||||
root = data_dir or get_settings().data_dir
|
||||
folder = root / "synthetic"
|
||||
if not folder.is_dir():
|
||||
return {}
|
||||
return {f.stem: f"data/synthetic/{f.name}" for f in sorted(folder.glob("*.jsonl"))}
|
||||
|
||||
|
||||
async def bot_username() -> str | None:
|
||||
"""Username of the running Telegram bot (deep links); None when the bot is not started (no TG_BOT_TOKEN)."""
|
||||
from app.channels import telegram
|
||||
|
||||
bot = getattr(telegram, "_bot", None)
|
||||
if bot is None:
|
||||
return None
|
||||
try:
|
||||
me = await bot.me() # aiogram caches getMe
|
||||
except Exception as exc: # noqa: BLE001 — network / auth errors: fall back to the web console link
|
||||
log.warning("bot username unavailable error=%s", type(exc).__name__)
|
||||
return None
|
||||
return me.username or None
|
||||
|
||||
|
||||
async def deep_link(code: str) -> str:
|
||||
username = await bot_username()
|
||||
return f"https://t.me/{username}?start={code}" if username else f"{CONSOLE_PATH}?code={code}"
|
||||
|
||||
|
||||
def memory_outbox() -> MemoryOutbox | None:
|
||||
"""The in-memory outbox polled by the web console, also when wrapped (Telegram keeps it as `fallback`)."""
|
||||
box: Outbox | None = integrations.outbox
|
||||
for _ in range(5):
|
||||
if isinstance(box, MemoryOutbox):
|
||||
return box
|
||||
box = getattr(box, "fallback", None)
|
||||
return None
|
||||
|
||||
|
||||
async def reset_demo() -> bool:
|
||||
"""Clock reset is done by the caller; re-seed via `scripts.seed_demo.reset()` (#18) when it exists."""
|
||||
box = memory_outbox()
|
||||
if box is not None:
|
||||
box._q.clear()
|
||||
try:
|
||||
spec = util.find_spec(SEED_MODULE)
|
||||
except ModuleNotFoundError: # no `scripts` package on the path (e.g. installed app without scripts/)
|
||||
spec = None
|
||||
if spec is None:
|
||||
return False
|
||||
reset = getattr(import_module(SEED_MODULE), "reset", None)
|
||||
if reset is None:
|
||||
return False
|
||||
result = reset()
|
||||
if inspect.isawaitable(result):
|
||||
await result
|
||||
return True
|
||||
@@ -0,0 +1,368 @@
|
||||
"""Doctor dashboard read models (#12): clinical DB rows → frozen API schemas (`app/api/schemas.py`).
|
||||
|
||||
Everything shown to the doctor is derived from stored structured data — no LLM decides colours, trends or the
|
||||
discontinuation risk (ADR-007). Time comes in as `now` (from `app.core.clock`, ADR-005).
|
||||
|
||||
Identity data (guardrail #5): the API is the doctor's display boundary, so it reads exactly two identity fields —
|
||||
`display_name` (minimal identification for the treating doctor) and `birth_year` (age). SNILS, phone and chat
|
||||
id are never selected into a response model.
|
||||
"""
|
||||
|
||||
from collections.abc import Iterable, Sequence
|
||||
from dataclasses import dataclass
|
||||
from datetime import date, datetime, timedelta
|
||||
from typing import Any, Literal, cast, get_args
|
||||
|
||||
from sqlalchemy import select
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.api.schemas import (
|
||||
AlertOut,
|
||||
Color,
|
||||
DiscontinuationRisk,
|
||||
DoseOut,
|
||||
LevelName,
|
||||
Metric,
|
||||
Module,
|
||||
PatientCard,
|
||||
PatientListItem,
|
||||
SeriesPoint,
|
||||
)
|
||||
from app.core.rules import color, patient_status
|
||||
from app.core.types import AlertLevel
|
||||
from app.db import repo
|
||||
from app.db.clinical import Alert, DailyCheckin, Dose, PatientProfile, Prescription, SafetyPlan, ScaleResult
|
||||
from app.db.identity import Patient
|
||||
from app.integrations.base import Prescription as PrescriptionOut
|
||||
|
||||
COLOR_ORDER: dict[str, int] = {"red": 0, "yellow": 1, "grey": 2, "green": 3}
|
||||
_MODULES = frozenset(get_args(Module))
|
||||
_METRICS = frozenset(get_args(Metric))
|
||||
_SCALE_LABELS = {"phq9": "PHQ-9", "pcl5": "PCL-5", "gad7": "GAD-7", "auditc": "AUDIT-C", "dar5": "DAR-5"}
|
||||
|
||||
# Daily check-in buckets → numbers for charts. Sleep: bucket midpoints in hours ("<4" plotted as 3, ">8" as 9).
|
||||
SLEEP_HOURS = {"<4": 3.0, "4-6": 5.0, "6-8": 7.0, ">8": 9.0}
|
||||
# Alcohol: 0 = none, 1 = 1–2 drinks, 2 = more (same coding as app/llm/summary.py expects).
|
||||
ALCOHOL_LEVEL = {"none": 0.0, "1-2": 1.0, "more": 2.0}
|
||||
|
||||
# Trend: the last two complete results of one scale. A change smaller than about half of the minimal clinically
|
||||
# important difference (PHQ-9: 5 points, PCL-5: 10 points) is reported as "flat" so noise does not flip arrows.
|
||||
TREND_MIN_CHANGE = {"phq9": 3, "pcl5": 5}
|
||||
|
||||
CARD_DAYS = 60 # how far back the card series / dose log reach
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------- discontinuation risk index
|
||||
#
|
||||
# Rule-based index (NOT a trained model) of the risk that the patient drops the therapy, 0–100, for sorting the
|
||||
# list and for the "talk about adherence" hint. Each factor is a deterministic check over the clinical DB with a
|
||||
# fixed weight; the score is the capped sum. Weights reflect the known predictors of early antidepressant
|
||||
# discontinuation (non-adherence, side effects in the first weeks, expressed intent to stop, low mood, alcohol):
|
||||
#
|
||||
# factor weight label for the doctor
|
||||
# missed/skipped doses on >= 3 of the last 7 days 30 "пропуски приёма N/7 дн."
|
||||
# ... on 1–2 of the last 7 days 15 "пропуски приёма N/7 дн."
|
||||
# side effects reported >= 3 days in a row 20 "побочные эффекты N дн. подряд"
|
||||
# ... 1–2 days in a row 10 "побочные эффекты N дн. подряд"
|
||||
# intent to stop medication voiced in last 14 days 25 "хотел бросить (день N)"
|
||||
# open, unacknowledged quit_intent alert +15 "не разобран сигнал «хочет бросить»"
|
||||
# mood <= 3 for >= 3 days in a row 15 "настроение ≤ 3 N дн. подряд"
|
||||
# alcohol on >= 3 of the last 7 days 15 "алкоголь N дн. из 7"
|
||||
# ... on 1–2 of the last 7 days 5 "алкоголь N дн. из 7"
|
||||
#
|
||||
# Level: >= 60 high, >= 30 medium, otherwise low. "Day" = calendar day in the clinic time zone; streaks end today
|
||||
# if today's check-in exists, otherwise yesterday (same anchor as app.core.rules), and a day without a check-in
|
||||
# breaks a streak — we never assume a symptom the patient did not report.
|
||||
|
||||
RISK_WINDOW_DAYS = 7
|
||||
QUIT_WINDOW_DAYS = 14
|
||||
MOOD_LOW = 3
|
||||
W_MISSED_MANY, W_MISSED_SOME = 30, 15
|
||||
W_SIDE_EFFECTS_LONG, W_SIDE_EFFECTS_SHORT = 20, 10
|
||||
W_QUIT_INTENT, W_QUIT_ALERT_OPEN = 25, 15
|
||||
W_MOOD_LOW = 15
|
||||
W_ALCOHOL_MANY, W_ALCOHOL_SOME = 15, 5
|
||||
STREAK_DAYS = 3
|
||||
RISK_HIGH, RISK_MEDIUM = 60, 30
|
||||
|
||||
|
||||
@dataclass
|
||||
class PatientData:
|
||||
"""Everything the list item and the card are computed from (one patient, loaded once)."""
|
||||
|
||||
profile: PatientProfile
|
||||
checkins: Sequence[DailyCheckin]
|
||||
results: Sequence[ScaleResult]
|
||||
doses: Sequence[Dose]
|
||||
prescriptions: Sequence[Prescription]
|
||||
alerts: Sequence[Alert] # newest first
|
||||
|
||||
|
||||
async def load_patient_data(session: AsyncSession, profile: PatientProfile) -> PatientData:
|
||||
token = profile.token
|
||||
doses = (await session.scalars(select(Dose).where(Dose.token == token).order_by(Dose.planned_at))).all()
|
||||
rx = (
|
||||
await session.scalars(select(Prescription).where(Prescription.token == token).order_by(Prescription.id))
|
||||
).all()
|
||||
return PatientData(
|
||||
profile=profile,
|
||||
checkins=await repo.list_checkins(session, token),
|
||||
results=await repo.list_scale_results(session, token),
|
||||
doses=doses,
|
||||
prescriptions=rx,
|
||||
alerts=await repo.list_alerts(session, token=token),
|
||||
)
|
||||
|
||||
|
||||
def _local(ts: datetime, now: datetime) -> date:
|
||||
return ts.astimezone(now.tzinfo).date()
|
||||
|
||||
|
||||
def _streak_days(checkins: Iterable[DailyCheckin], today: date, pred: Any) -> int:
|
||||
"""Length of the run of consecutive check-in days satisfying `pred`, ending at the anchor day."""
|
||||
by_day = {c.day: c for c in checkins if c.day <= today}
|
||||
day = today if today in by_day else today - timedelta(days=1)
|
||||
n = 0
|
||||
while (c := by_day.get(day)) is not None and pred(c):
|
||||
n += 1
|
||||
day -= timedelta(days=1)
|
||||
return n
|
||||
|
||||
|
||||
def _therapy_day(profile: PatientProfile, day: date) -> int:
|
||||
return (day - profile.therapy_start).days if profile.therapy_start else 0
|
||||
|
||||
|
||||
def _missed_days(d: PatientData, now: datetime, first: date) -> set[date]:
|
||||
# Same sources as rule missed_doses_7d: dose records and the check-in answer "did not take".
|
||||
days = {_local(x.planned_at, now) for x in d.doses if x.status in ("missed", "skipped") and x.planned_at <= now}
|
||||
days |= {c.day for c in d.checkins if c.med_taken is False}
|
||||
return {x for x in days if first <= x <= now.date()}
|
||||
|
||||
|
||||
def discontinuation_risk(d: PatientData, now: datetime) -> DiscontinuationRisk:
|
||||
"""Deterministic discontinuation-risk index; see the weight table above."""
|
||||
today = now.date()
|
||||
first = today - timedelta(days=RISK_WINDOW_DAYS - 1)
|
||||
score = 0
|
||||
factors: list[str] = []
|
||||
|
||||
missed = len(_missed_days(d, now, first))
|
||||
if missed:
|
||||
score += W_MISSED_MANY if missed >= STREAK_DAYS else W_MISSED_SOME
|
||||
factors.append(f"пропуски приёма {missed}/{RISK_WINDOW_DAYS} дн.")
|
||||
|
||||
side = _streak_days(d.checkins, today, lambda c: bool(c.side_effects))
|
||||
if side:
|
||||
score += W_SIDE_EFFECTS_LONG if side >= STREAK_DAYS else W_SIDE_EFFECTS_SHORT
|
||||
factors.append(f"побочные эффекты {side} дн. подряд")
|
||||
|
||||
quit_since = today - timedelta(days=QUIT_WINDOW_DAYS - 1)
|
||||
quit_days = [c.day for c in d.checkins if c.quit_intent and quit_since <= c.day <= today]
|
||||
if quit_days:
|
||||
score += W_QUIT_INTENT
|
||||
factors.append(f"хотел бросить (день {_therapy_day(d.profile, max(quit_days))})")
|
||||
if any(a.code == "quit_intent" and a.acked_at is None for a in d.alerts):
|
||||
score += W_QUIT_ALERT_OPEN
|
||||
factors.append("не разобран сигнал «хочет бросить»")
|
||||
|
||||
low = _streak_days(d.checkins, today, lambda c: c.mood is not None and c.mood <= MOOD_LOW)
|
||||
if low >= STREAK_DAYS:
|
||||
score += W_MOOD_LOW
|
||||
factors.append(f"настроение ≤ {MOOD_LOW} {low} дн. подряд")
|
||||
|
||||
drinking = sum(1 for c in d.checkins if first <= c.day <= today and c.alcohol_bucket not in (None, "none"))
|
||||
if drinking:
|
||||
score += W_ALCOHOL_MANY if drinking >= STREAK_DAYS else W_ALCOHOL_SOME
|
||||
factors.append(f"алкоголь {drinking} дн. из {RISK_WINDOW_DAYS}")
|
||||
|
||||
score = min(score, 100)
|
||||
level: Literal["low", "medium", "high"] = (
|
||||
"high" if score >= RISK_HIGH else "medium" if score >= RISK_MEDIUM else "low"
|
||||
)
|
||||
return DiscontinuationRisk(score=score, level=level, factors=factors)
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------- list item
|
||||
|
||||
|
||||
def _complete(d: PatientData, scale: str) -> list[ScaleResult]:
|
||||
return [r for r in d.results if r.scale == scale and r.complete] # repo returns them oldest first
|
||||
|
||||
|
||||
def trend(d: PatientData) -> Literal["up", "down", "flat", "unknown"]:
|
||||
"""Direction of symptom scores (up = worse) from the scale with the most recent pair of results."""
|
||||
pairs = [(s, rs[-2:]) for s in TREND_MIN_CHANGE if len(rs := _complete(d, s)) >= 2]
|
||||
if not pairs:
|
||||
return "unknown"
|
||||
scale, (prev, last) = max(pairs, key=lambda p: p[1][-1].ts)
|
||||
delta = last.total - prev.total
|
||||
if abs(delta) < TREND_MIN_CHANGE[scale]:
|
||||
return "flat"
|
||||
return "up" if delta > 0 else "down"
|
||||
|
||||
|
||||
def adherence_7d(d: PatientData, now: datetime) -> float | None:
|
||||
"""Taken / planned doses of the last 7 days; doses still `pending` (not resolved yet) are not counted."""
|
||||
since = now - timedelta(days=RISK_WINDOW_DAYS)
|
||||
resolved = [x for x in d.doses if since < x.planned_at <= now and x.status != "pending"]
|
||||
if not resolved:
|
||||
return None
|
||||
return round(sum(1 for x in resolved if x.status == "taken") / len(resolved), 2)
|
||||
|
||||
|
||||
def _drug_label(rx: Prescription) -> str:
|
||||
return f"{rx.drug} {rx.dose}".strip()
|
||||
|
||||
|
||||
def _active_rx(d: PatientData, today: date) -> Prescription | None:
|
||||
active = [
|
||||
r
|
||||
for r in d.prescriptions
|
||||
if (r.start_date is None or r.start_date <= today) and (r.end_date is None or r.end_date >= today)
|
||||
]
|
||||
return (active or list(d.prescriptions) or [None])[-1]
|
||||
|
||||
|
||||
def _last_event(d: PatientData, now: datetime) -> str:
|
||||
alert = d.alerts[0] if d.alerts else None
|
||||
scales = [r for r in d.results if r.complete and r.scale in _SCALE_LABELS]
|
||||
scale = scales[-1] if scales else None
|
||||
if scale is not None and (alert is None or scale.ts > alert.ts):
|
||||
day = _therapy_day(d.profile, _local(scale.ts, now))
|
||||
return f"{_SCALE_LABELS[scale.scale]} = {scale.total} (день {day})"
|
||||
return alert.reason if alert is not None else ""
|
||||
|
||||
|
||||
def _age(patient: Patient | None, profile: PatientProfile, today: date) -> int:
|
||||
birth_year = (patient.birth_year if patient else None) or profile.birth_year
|
||||
return today.year - birth_year if birth_year else 0
|
||||
|
||||
|
||||
def list_item(d: PatientData, patient: Patient | None, now: datetime) -> PatientListItem:
|
||||
p = d.profile
|
||||
today = now.date()
|
||||
open_alerts = [a for a in d.alerts if a.acked_at is None]
|
||||
# ADR-006: the colour is derived from open alert levels (the source of truth), not from the cached column.
|
||||
status = patient_status(AlertLevel[a.level.upper()] for a in open_alerts)
|
||||
phq9, pcl5 = _complete(d, "phq9"), _complete(d, "pcl5")
|
||||
rx = _active_rx(d, today)
|
||||
return PatientListItem(
|
||||
token=p.token,
|
||||
display_name=patient.display_name if patient else "Пациент",
|
||||
age=_age(patient, p, today),
|
||||
modules=[cast(Module, m) for m in p.modules or [] if m in _MODULES],
|
||||
drug=_drug_label(rx) if rx else None,
|
||||
therapy_day=_therapy_day(p, today),
|
||||
next_visit=p.next_visit,
|
||||
status_color=status.color,
|
||||
top_alert_level=cast(LevelName, status.top_level.name.lower()) if status.top_level is not None else None,
|
||||
open_alerts=len(open_alerts),
|
||||
phq9_last=phq9[-1].total if phq9 else None,
|
||||
pcl5_last=pcl5[-1].total if pcl5 else None,
|
||||
trend=trend(d),
|
||||
adherence_7d=adherence_7d(d, now),
|
||||
discontinuation_risk=discontinuation_risk(d, now),
|
||||
last_event=_last_event(d, now),
|
||||
)
|
||||
|
||||
|
||||
def sort_key(item: PatientListItem) -> tuple[int, int, str]:
|
||||
"""red → yellow → grey → green, then discontinuation risk (desc), then name for a stable order."""
|
||||
return (COLOR_ORDER[item.status_color], -item.discontinuation_risk.score, item.display_name)
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------- card
|
||||
|
||||
|
||||
def alert_out(a: Alert, patient_name: str) -> AlertOut:
|
||||
level = cast(LevelName, a.level)
|
||||
return AlertOut(
|
||||
id=a.id,
|
||||
token=a.token,
|
||||
patient_name=patient_name,
|
||||
ts=a.ts,
|
||||
level=level,
|
||||
color=cast(Color, color([AlertLevel[a.level.upper()]])),
|
||||
code=a.code,
|
||||
reason=a.reason,
|
||||
acked_by=a.acked_by,
|
||||
acked_at=a.acked_at,
|
||||
)
|
||||
|
||||
|
||||
def series(d: PatientData, now: datetime) -> list[SeriesPoint]:
|
||||
since = now.date() - timedelta(days=CARD_DAYS)
|
||||
out: list[SeriesPoint] = []
|
||||
for c in d.checkins:
|
||||
if not since <= c.day <= now.date():
|
||||
continue
|
||||
if c.mood is not None:
|
||||
out.append(SeriesPoint(day=c.day, metric="mood", value=float(c.mood)))
|
||||
if c.sleep_bucket in SLEEP_HOURS:
|
||||
out.append(SeriesPoint(day=c.day, metric="sleep_hours", value=SLEEP_HOURS[c.sleep_bucket]))
|
||||
if c.alcohol_bucket in ALCOHOL_LEVEL:
|
||||
out.append(SeriesPoint(day=c.day, metric="alcohol", value=ALCOHOL_LEVEL[c.alcohol_bucket]))
|
||||
for r in d.results:
|
||||
day = _local(r.ts, now)
|
||||
if r.complete and r.scale in _METRICS and since <= day and r.ts <= now:
|
||||
out.append(SeriesPoint(day=day, metric=cast(Metric, r.scale), value=float(r.total), scheduled=r.scheduled))
|
||||
return sorted(out, key=lambda p: (p.day, p.metric))
|
||||
|
||||
|
||||
def doses(d: PatientData, now: datetime) -> list[DoseOut]:
|
||||
labels = {r.id: _drug_label(r) for r in d.prescriptions}
|
||||
since = now - timedelta(days=CARD_DAYS)
|
||||
return [
|
||||
DoseOut(planned_at=x.planned_at, drug=labels.get(x.prescription_id, ""), status=x.status) # type: ignore[arg-type]
|
||||
for x in d.doses
|
||||
if since <= x.planned_at <= now + timedelta(days=1)
|
||||
]
|
||||
|
||||
|
||||
def prescriptions(d: PatientData) -> list[PrescriptionOut]:
|
||||
out = []
|
||||
for r in d.prescriptions:
|
||||
schedule = dict(r.schedule or {})
|
||||
out.append(
|
||||
PrescriptionOut(
|
||||
drug=r.drug,
|
||||
dose=r.dose,
|
||||
schedule={"times": [str(t) for t in schedule.get("times", [])]},
|
||||
instructions=" ".join(str(t) for t in _as_list(schedule.get("instructions"))),
|
||||
start_date=r.start_date,
|
||||
end_date=r.end_date,
|
||||
)
|
||||
)
|
||||
return out
|
||||
|
||||
|
||||
def _as_list(value: Any) -> list[Any]:
|
||||
if value is None:
|
||||
return []
|
||||
return list(value) if isinstance(value, list) else [value]
|
||||
|
||||
|
||||
def _plan_line(step: Any) -> str:
|
||||
# Same rendering as the dialog's safety-plan reply (app/dialog/actions.py).
|
||||
if isinstance(step, dict):
|
||||
return ": ".join(str(v) for v in step.values() if v)
|
||||
return str(step)
|
||||
|
||||
|
||||
async def safety_plan(session: AsyncSession, token: str) -> list[str] | None:
|
||||
row = await session.get(SafetyPlan, token)
|
||||
return [_plan_line(s) for s in row.steps] if row is not None and row.steps else None
|
||||
|
||||
|
||||
async def build_card(session: AsyncSession, d: PatientData, patient: Patient | None, now: datetime) -> PatientCard:
|
||||
"""Card without the summary (the caller adds it: the LLM call must not hold the DB session)."""
|
||||
item = list_item(d, patient, now)
|
||||
return PatientCard(
|
||||
patient=item,
|
||||
prescriptions=prescriptions(d),
|
||||
series=series(d, now),
|
||||
doses=doses(d, now),
|
||||
alerts=[alert_out(a, item.display_name) for a in d.alerts],
|
||||
safety_plan=await safety_plan(session, d.profile.token),
|
||||
)
|
||||
+13
-6
@@ -27,6 +27,7 @@ from pydantic import BaseModel, ConfigDict, Field
|
||||
from sqlalchemy import select
|
||||
|
||||
from app.api import fixtures
|
||||
from app.api.schemas import DemoPersona
|
||||
from app.core import clock
|
||||
from app.core.instrument_catalog import Catalog, catalog
|
||||
from app.core.intake_questions import DIARY_KINDS
|
||||
@@ -133,9 +134,15 @@ async def auth_emias(body: EmiasCodeIn) -> AuthOut:
|
||||
return AuthOut(token=person.token, mode="emias")
|
||||
|
||||
|
||||
@router.get("/patient/demo-personas", response_model=list[DemoPersona])
|
||||
async def patient_demo_personas() -> list[DemoPersona]:
|
||||
"""Synthetic ЕМИАС accounts for the patient app sign-in (the demo console has its own `/demo/personas`)."""
|
||||
return fixtures.DEMO_PERSONAS
|
||||
|
||||
|
||||
@router.post("/auth/emias/demo", response_model=AuthOut)
|
||||
async def auth_emias_demo(body: EmiasDemoIn) -> AuthOut:
|
||||
"""Demo ЕМИАС account: signs in as one of the synthetic personas (`/demo/personas`)."""
|
||||
"""Demo ЕМИАС account: signs in as one of the synthetic personas (`/patient/demo-personas`)."""
|
||||
persona = next((p for p in fixtures.DEMO_PERSONAS if p.token == body.persona_token), None)
|
||||
if persona is None:
|
||||
raise HTTPException(404, "persona not found")
|
||||
@@ -148,13 +155,13 @@ async def auth_emias_demo(body: EmiasDemoIn) -> AuthOut:
|
||||
async def auth_anonymous(body: AnonymousIn | None = None) -> AuthOut:
|
||||
"""Anonymous sign-in: a fresh random token; no identity record, no doctor.
|
||||
|
||||
With `focus` a doctor-less pseudonymous profile keeps only the chosen module, so the engine starts the
|
||||
matching onboarding instead of going straight to the menu. Without it nothing is stored at all.
|
||||
The clinical side gets a doctor-less pseudonymous profile (the dialog API serves known profiles only). It holds
|
||||
no personal data — only the module of the chosen `focus`; the stage 1 screening then sets the modules itself.
|
||||
"""
|
||||
token = secrets.token_hex(TOKEN_LEN // 2)
|
||||
if body is not None and body.focus is not None:
|
||||
async with get_clinical_session() as s:
|
||||
await repo.upsert_profile(s, token=token, doctor_id="", modules=[_FOCUS_MODULE[body.focus]])
|
||||
focus = body.focus if body is not None else None
|
||||
async with get_clinical_session() as s:
|
||||
await repo.upsert_profile(s, token=token, doctor_id="", modules=[_FOCUS_MODULE[focus]] if focus else [])
|
||||
log.info("web auth: anonymous tok=%s", token[:6])
|
||||
return AuthOut(token=token, mode="anonymous")
|
||||
|
||||
|
||||
+193
-24
@@ -1,11 +1,20 @@
|
||||
"""API routes `/api/v1` (#34 stubs → #12 implementation).
|
||||
"""API routes `/api/v1` (#34 contract → #12 implementation).
|
||||
|
||||
Stubs return deterministic fixtures (`app/api/fixtures.py`) so the dashboard can be built immediately.
|
||||
Lane B replaces bodies in #12 without changing paths or schemas (those are the frozen contract).
|
||||
Paths and schemas are the frozen contract (`app/api/schemas.py`); bodies read the identity and clinical DBs.
|
||||
Read models live in `app/api/doctor_views.py`, demo-console helpers in `app/api/demo.py`.
|
||||
Every doctor access to patient data is written to `audit_log` (guardrail #6): `view_patient_list`,
|
||||
`view_patient` (also a denied attempt: `view_patient_denied`), `view_alerts` (only when new alerts are
|
||||
disclosed — the dashboard polls every 2–3 s), `ack_alert` (in `repo.ack_alert`), `connect_patient`.
|
||||
`app/api/fixtures.py` is kept for tests and as the demo cabinet reference (doctor id).
|
||||
"""
|
||||
|
||||
from fastapi import APIRouter, HTTPException
|
||||
import secrets
|
||||
|
||||
from fastapi import APIRouter, HTTPException
|
||||
from sqlalchemy import select
|
||||
|
||||
from app.api import demo as console
|
||||
from app.api import doctor_views as views
|
||||
from app.api import fixtures
|
||||
from app.api.patient_web import router as patient_web_router
|
||||
from app.api.questionnaire import router as questionnaire_router
|
||||
@@ -24,70 +33,204 @@ from app.api.schemas import (
|
||||
PatientListItem,
|
||||
)
|
||||
from app.core import clock
|
||||
from app.dialog.contracts import get_engine
|
||||
from app.integrations.base import MemoryOutbox, integrations
|
||||
from app.core.privacy import pseudo_id
|
||||
from app.db import identity_repo, repo
|
||||
from app.db.audit import audit
|
||||
from app.db.clinical import Alert, Message, PatientProfile
|
||||
from app.db.clinical import Prescription as PrescriptionRow
|
||||
from app.db.identity import Patient
|
||||
from app.db.session import get_clinical_session, get_identity_session
|
||||
from app.dialog.contracts import Event, get_engine
|
||||
from app.integrations.base import integrations
|
||||
from app.scheduler import jobs as scheduler
|
||||
from app.services.monitoring import refresh_status
|
||||
|
||||
router = APIRouter(prefix="/api/v1")
|
||||
router.include_router(questionnaire_router)
|
||||
router.include_router(patient_web_router)
|
||||
|
||||
DEFAULT_CLINIC = "clinic-demo"
|
||||
CODE_ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789" # no 0/O/1/I: the code may be typed by hand
|
||||
CODE_LEN = 8
|
||||
|
||||
|
||||
async def _patients(tokens: list[str]) -> dict[str, Patient]:
|
||||
"""Identity rows for display name / age only (never put SNILS or phone into a response)."""
|
||||
if not tokens:
|
||||
return {}
|
||||
async with get_identity_session() as s:
|
||||
rows = (await s.scalars(select(Patient).where(Patient.token.in_(tokens)))).all()
|
||||
return {p.token: p for p in rows}
|
||||
|
||||
|
||||
def _name(patients: dict[str, Patient], token: str) -> str:
|
||||
p = patients.get(token)
|
||||
return p.display_name if p else "Пациент"
|
||||
|
||||
|
||||
# ------------------------------------------------------------------ doctor dashboard
|
||||
@router.get("/doctors/{doctor_id}/patients", response_model=list[PatientListItem], tags=["doctor"])
|
||||
async def list_patients(doctor_id: str) -> list[PatientListItem]:
|
||||
"""Doctor's patients sorted red → yellow → grey → green, then by discontinuation risk."""
|
||||
order = {"red": 0, "yellow": 1, "grey": 2, "green": 3}
|
||||
return sorted(fixtures.PATIENTS, key=lambda p: (order[p.status_color], -p.discontinuation_risk.score))
|
||||
now = clock.now()
|
||||
async with get_clinical_session() as s:
|
||||
profiles = await repo.patients_of_doctor(s, doctor_id)
|
||||
data = [await views.load_patient_data(s, p) for p in profiles]
|
||||
await audit(s, actor=doctor_id, action="view_patient_list", token=None, details={"count": len(data)}, ts=now)
|
||||
patients = await _patients([p.token for p in profiles])
|
||||
items = [views.list_item(d, patients.get(d.profile.token), now) for d in data]
|
||||
return sorted(items, key=views.sort_key)
|
||||
|
||||
|
||||
@router.get("/patients/{token}", response_model=PatientCard, tags=["doctor"])
|
||||
async def patient_card(token: str, doctor_id: str) -> PatientCard:
|
||||
"""Patient card. Every call is written to audit_log as `view_patient` (#12)."""
|
||||
card = fixtures.card(token)
|
||||
if card is None:
|
||||
raise HTTPException(404, "patient not found")
|
||||
"""Patient card. Every call is written to audit_log as `view_patient`; only the attending doctor may read it."""
|
||||
now = clock.now()
|
||||
patient = (await _patients([token])).get(token)
|
||||
async with get_clinical_session() as s:
|
||||
profile = await repo.get_profile(s, token)
|
||||
if profile is None:
|
||||
raise HTTPException(404, "patient not found")
|
||||
if profile.doctor_id != doctor_id:
|
||||
await audit(s, actor=doctor_id, action="view_patient_denied", token=token, ts=now)
|
||||
await s.commit()
|
||||
raise HTTPException(403, "not your patient")
|
||||
data = await views.load_patient_data(s, profile)
|
||||
card = await views.build_card(s, data, patient, now)
|
||||
await audit(s, actor=doctor_id, action="view_patient", token=token, ts=now)
|
||||
# Summary after the commit: the (possibly slow) LLM call must not hold the DB transaction.
|
||||
from app.llm.summary import build_summary # summary imports app.api.schemas; avoid an import cycle
|
||||
|
||||
card.summary = await build_summary(card, today=now.date())
|
||||
return card
|
||||
|
||||
|
||||
@router.get("/doctors/{doctor_id}/alerts", response_model=list[AlertOut], tags=["doctor"])
|
||||
async def list_alerts(doctor_id: str, since_id: int = -1, open_only: bool = False) -> list[AlertOut]:
|
||||
"""Polled every 2–3 s by the dashboard: alerts with id > since_id, newest first."""
|
||||
alerts = [a for a in fixtures.all_alerts() if a.id > since_id]
|
||||
return [a for a in alerts if a.acked_at is None] if open_only else alerts
|
||||
async with get_clinical_session() as s:
|
||||
tokens = list(await s.scalars(select(PatientProfile.token).where(PatientProfile.doctor_id == doctor_id)))
|
||||
stmt = select(Alert).where(Alert.token.in_(tokens), Alert.id > since_id)
|
||||
if open_only:
|
||||
stmt = stmt.where(Alert.acked_at.is_(None))
|
||||
alerts = (await s.scalars(stmt.order_by(Alert.ts.desc(), Alert.id.desc()))).all()
|
||||
if alerts:
|
||||
await audit(
|
||||
s,
|
||||
actor=doctor_id,
|
||||
action="view_alerts",
|
||||
token=None,
|
||||
details={"alert_ids": [a.id for a in alerts][:50], "count": len(alerts)},
|
||||
ts=clock.now(),
|
||||
)
|
||||
patients = await _patients(sorted({a.token for a in alerts}))
|
||||
return [views.alert_out(a, _name(patients, a.token)) for a in alerts]
|
||||
|
||||
|
||||
@router.post("/alerts/{alert_id}/ack", response_model=AlertOut, tags=["doctor"])
|
||||
async def ack_alert(alert_id: int, body: AckIn) -> AlertOut:
|
||||
"""Doctor acknowledges an alert (written to audit_log). Acking an acute alert lets the patient leave crisis."""
|
||||
alert = next((a for a in fixtures.all_alerts() if a.id == alert_id), None)
|
||||
if alert is None:
|
||||
raise HTTPException(404, "alert not found")
|
||||
return alert.model_copy(update={"acked_by": body.doctor_id, "acked_at": clock.now()})
|
||||
now = clock.now()
|
||||
async with get_clinical_session() as s:
|
||||
alert = await s.get(Alert, alert_id)
|
||||
if alert is None:
|
||||
raise HTTPException(404, "alert not found")
|
||||
profile = await repo.get_profile(s, alert.token)
|
||||
if profile is None or profile.doctor_id != body.doctor_id:
|
||||
raise HTTPException(403, "not your patient")
|
||||
await repo.ack_alert(s, alert_id=alert_id, doctor_id=body.doctor_id, ts=now)
|
||||
await refresh_status(s, alert.token)
|
||||
open_acute = [a for a in await repo.list_alerts(s, token=alert.token, open_only=True) if a.level == "acute"]
|
||||
out = views.alert_out(alert, "")
|
||||
# The crisis ends only when no acute alert is left open (another acute signal keeps the patient in crisis).
|
||||
if alert.level == "acute" and not open_acute:
|
||||
replies = await get_engine().handle(alert.token, Event(type="system", system="doctor_ack"))
|
||||
if replies:
|
||||
await integrations.outbox.push(alert.token, replies)
|
||||
return out.model_copy(update={"patient_name": _name(await _patients([alert.token]), alert.token)})
|
||||
|
||||
|
||||
@router.post("/patients/connect", response_model=ConnectPatientOut, tags=["doctor"])
|
||||
async def connect_patient(body: ConnectPatientIn) -> ConnectPatientOut:
|
||||
"""Doctor connects a patient after the in-person visit (323-FZ art. 36.2): prescription → МИС mock, code/QR."""
|
||||
return ConnectPatientOut(token="tok-new", code="DEMO-0001", deep_link="https://t.me/ptsr_demo_bot?start=DEMO-0001")
|
||||
now = clock.now()
|
||||
try:
|
||||
token = pseudo_id(body.snils)
|
||||
except ValueError as exc:
|
||||
raise HTTPException(422, "SNILS must contain 11 digits") from exc
|
||||
code = "".join(secrets.choice(CODE_ALPHABET) for _ in range(CODE_LEN))
|
||||
async with get_identity_session() as ids:
|
||||
if await identity_repo.get_patient(ids, token) is not None:
|
||||
raise HTTPException(409, "patient already connected")
|
||||
doctor = await identity_repo.get_doctor(ids, body.doctor_id)
|
||||
await identity_repo.create_patient(
|
||||
ids,
|
||||
token=token,
|
||||
display_name=body.display_name,
|
||||
snils=body.snils,
|
||||
clinic_id=doctor.clinic_id if doctor else DEFAULT_CLINIC,
|
||||
doctor_id=body.doctor_id,
|
||||
now=now,
|
||||
birth_year=body.birth_year,
|
||||
sex=body.sex,
|
||||
)
|
||||
await identity_repo.create_connect_code(ids, code=code, token=token, doctor_id=body.doctor_id, now=now)
|
||||
# Clinical writes nested inside the identity unit of work: if they fail, the identity row rolls back too.
|
||||
async with get_clinical_session() as s:
|
||||
await repo.upsert_profile(
|
||||
s,
|
||||
token=token,
|
||||
doctor_id=body.doctor_id,
|
||||
modules=list(body.modules),
|
||||
therapy_start=now.date(),
|
||||
next_visit=body.next_visit,
|
||||
birth_year=body.birth_year,
|
||||
sex=body.sex,
|
||||
)
|
||||
schedule: dict[str, list[str]] = {"times": list(body.times)}
|
||||
if body.instructions:
|
||||
schedule["instructions"] = [body.instructions]
|
||||
s.add(
|
||||
PrescriptionRow(token=token, drug=body.drug, dose=body.dose, schedule=schedule, start_date=now.date())
|
||||
)
|
||||
await audit(
|
||||
s,
|
||||
actor=body.doctor_id,
|
||||
action="connect_patient",
|
||||
token=token,
|
||||
details={"modules": list(body.modules), "drug": body.drug},
|
||||
ts=now,
|
||||
)
|
||||
return ConnectPatientOut(token=token, code=code, deep_link=await console.deep_link(code))
|
||||
|
||||
|
||||
# ------------------------------------------------------------------ patient dialog (web console / any channel)
|
||||
async def _require_patient(token: str) -> None:
|
||||
async with get_clinical_session() as s:
|
||||
if await repo.get_profile(s, token) is None:
|
||||
raise HTTPException(404, "patient not found")
|
||||
|
||||
|
||||
@router.post("/dialog/{token}/events", response_model=DialogOut, tags=["dialog"])
|
||||
async def dialog_event(token: str, body: DialogIn) -> DialogOut:
|
||||
await _require_patient(token)
|
||||
return DialogOut(replies=await get_engine().handle(token, body))
|
||||
|
||||
|
||||
@router.get("/dialog/{token}/outbox", response_model=DialogOut, tags=["dialog"])
|
||||
async def dialog_outbox(token: str) -> DialogOut:
|
||||
"""System-initiated replies (reminders, check-ins) waiting for the web console."""
|
||||
box = integrations.outbox
|
||||
return DialogOut(replies=box.drain(token) if isinstance(box, MemoryOutbox) else [])
|
||||
box = console.memory_outbox()
|
||||
return DialogOut(replies=box.drain(token) if box is not None else [])
|
||||
|
||||
|
||||
@router.get("/dialog/{token}/history", response_model=list[MessageOut], tags=["dialog"])
|
||||
async def dialog_history(token: str, limit: int = 100) -> list[MessageOut]:
|
||||
return []
|
||||
"""Stored dialog (texts are scrubbed before storage, ADR-003), oldest first, the last `limit` messages."""
|
||||
async with get_clinical_session() as s:
|
||||
stmt = select(Message).where(Message.token == token).order_by(Message.ts.desc(), Message.id.desc())
|
||||
rows = (await s.scalars(stmt.limit(max(1, min(limit, 1000))))).all()
|
||||
return [MessageOut(ts=m.ts, direction=m.direction, text=m.text_scrubbed) for m in reversed(rows)] # type: ignore[arg-type]
|
||||
|
||||
|
||||
# ------------------------------------------------------------------ demo controls (ADR-005)
|
||||
@@ -110,10 +253,36 @@ async def advance_clock(body: ClockAdvanceIn) -> ClockOut:
|
||||
|
||||
@router.post("/demo/reset", tags=["demo"])
|
||||
async def demo_reset() -> dict[str, str]:
|
||||
"""Clock back to the wall clock, console outbox emptied, demo data re-seeded by `scripts.seed_demo` (#18)."""
|
||||
clock.reset()
|
||||
return {"status": "ok"}
|
||||
seeded = await console.reset_demo()
|
||||
return {"status": "ok", "seed": "reset" if seeded else "skipped"}
|
||||
|
||||
|
||||
@router.get("/demo/personas", response_model=list[DemoPersona], tags=["demo"])
|
||||
async def demo_personas() -> list[DemoPersona]:
|
||||
return fixtures.DEMO_PERSONAS
|
||||
"""Patients with a scripted scenario `data/synthetic/<slug>.jsonl`; the demo cabinet's doctor first."""
|
||||
scenarios = console.scenario_files()
|
||||
if not scenarios:
|
||||
return []
|
||||
async with get_identity_session() as ids:
|
||||
patients = (await ids.scalars(select(Patient))).all()
|
||||
scripted = [(p, scenarios[slug]) for p in patients if (slug := console.persona_slug(p.display_name)) in scenarios]
|
||||
if not scripted:
|
||||
return []
|
||||
today = clock.today()
|
||||
async with get_clinical_session() as s:
|
||||
profiles = {p.token: await repo.get_profile(s, p.token) for p, _ in scripted}
|
||||
out = []
|
||||
for p, path in sorted(scripted, key=lambda x: (x[0].doctor_id != fixtures.DOCTOR_ID, x[0].display_name)):
|
||||
profile = profiles.get(p.token)
|
||||
start = profile.therapy_start if profile else None
|
||||
out.append(
|
||||
DemoPersona(
|
||||
token=p.token,
|
||||
display_name=p.display_name,
|
||||
therapy_day=(today - start).days if start else 0,
|
||||
scenario=path,
|
||||
)
|
||||
)
|
||||
return out
|
||||
|
||||
@@ -28,6 +28,16 @@ class Settings(BaseSettings):
|
||||
gigachat_model: str = "GigaChat"
|
||||
gigachat_verify_ssl: bool = False
|
||||
|
||||
# Chat agent (tool-using LLM over RAG + patient record). `auto` = OpenRouter if a key is set, else off
|
||||
# (extractive RAG / instruction answers stay). OpenRouter is a TEMPORARY prototype provider on synthetic
|
||||
# data only — prod must use GigaChat (152-FZ, foreign services are forbidden for real PII).
|
||||
chat_agent: Literal["auto", "off", "mock", "openrouter", "gigachat"] = "auto"
|
||||
openrouter_api_key: str = ""
|
||||
openrouter_model: str = "google/gemini-2.5-flash-lite"
|
||||
openrouter_base_url: str = "https://openrouter.ai/api/v1"
|
||||
chat_agent_timeout_s: float = 25.0
|
||||
chat_agent_max_steps: int = 5
|
||||
|
||||
# Telegram is used only for the prototype on synthetic data; prod channel is MAX / Gosuslugi.
|
||||
tg_bot_token: str = ""
|
||||
doctor_notify_chat_id: int | None = None
|
||||
|
||||
@@ -39,6 +39,7 @@ def menu_reply(ctx: Ctx, text: str | None = None) -> Reply:
|
||||
buttons = [
|
||||
[Button(label=b.checkin, data="menu:checkin")],
|
||||
[Button(label=b.med_question, data="menu:med_question")],
|
||||
[Button(label=b.kb_question, data="menu:kb_question")],
|
||||
[Button(label=b.contact_doctor, data="menu:contact_doctor")],
|
||||
[Button(label=b.revoke, data="consent:revoke")],
|
||||
]
|
||||
|
||||
@@ -0,0 +1,107 @@
|
||||
"""Questions about the condition and its treatment → knowledge base of clinical guidelines (#64, RAG #60).
|
||||
|
||||
menu «Вопрос о лечении» ──▶ kb.question (free text) ──▶ rag.answer: KR quote + source, or «уточните у врача»
|
||||
free text in idle that looks like a question (veteran_daily `text:idle`, after the check-in signals and the
|
||||
drug question) ──▶ rag.answer, or the usual support phrase when the KB has no answer
|
||||
|
||||
The engine has already scrubbed the text, checked consent and run the safety check (ACUTE never gets here).
|
||||
Questions about the patient's own drug stay with `med_qa` (instruction only, SPEC §7 п.5); this flow answers
|
||||
general questions from the guidelines, extractively and without doses (`app.llm.rag.qa`). Logs carry codes only.
|
||||
"""
|
||||
|
||||
import logging
|
||||
import re
|
||||
from functools import lru_cache
|
||||
from pathlib import Path
|
||||
|
||||
import yaml
|
||||
from pydantic import BaseModel, ConfigDict
|
||||
|
||||
from app.config import get_settings
|
||||
from app.dialog.contracts import Event, Reply
|
||||
from app.dialog.flows.core import menu_reply
|
||||
from app.dialog.fsm import Ctx, Step, abandonable, handler_for, state, trigger
|
||||
from app.llm import agent, rag
|
||||
from app.llm.med_qa import DOSE_QUESTION
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
QUESTION_STATE = "kb.question"
|
||||
# `scrub()` placeholders and the punctuation around them: "[NAME], что такое ПТСР?" starts with "что такое".
|
||||
_PLACEHOLDERS = re.compile(r"^(?:\s*\[[A-Z_]+\][\s,.:;!-]*)+")
|
||||
|
||||
|
||||
class KnowledgeTexts(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid", frozen=True)
|
||||
|
||||
prompt: str
|
||||
dose_redirect: str
|
||||
question_starts: list[str]
|
||||
small_talk: list[str]
|
||||
|
||||
|
||||
@lru_cache
|
||||
def load_knowledge_texts(path: Path | None = None) -> KnowledgeTexts:
|
||||
path = path or get_settings().config_dir / "texts" / "knowledge.yaml"
|
||||
return KnowledgeTexts.model_validate(yaml.safe_load(path.read_text(encoding="utf-8")))
|
||||
|
||||
|
||||
@lru_cache
|
||||
def _question_start() -> re.Pattern[str]:
|
||||
starts = sorted(load_knowledge_texts().question_starts, key=len, reverse=True)
|
||||
return re.compile(r"^\s*(?:" + "|".join(re.escape(s) for s in starts) + r")\b", re.IGNORECASE)
|
||||
|
||||
|
||||
@lru_cache
|
||||
def _small_talk() -> re.Pattern[str]:
|
||||
return re.compile(r"\b(?:" + "|".join(re.escape(s) for s in load_knowledge_texts().small_talk) + r")\b", re.I)
|
||||
|
||||
|
||||
def looks_like_question(text: str) -> bool:
|
||||
"""A "?" anywhere or a question word at the start ("что такое флэшбек", "можно ли ..."); small talk
|
||||
("как дела?") is not a question for the knowledge base."""
|
||||
text = _PLACEHOLDERS.sub("", text)
|
||||
if _small_talk().search(text):
|
||||
return False
|
||||
return "?" in text or bool(_question_start().search(text))
|
||||
|
||||
|
||||
async def knowledge_answer(ctx: Ctx, *, explicit: bool) -> str | None:
|
||||
"""KB answer for `ctx.text`. No answer → «уточните у врача» if the patient asked via the menu (`explicit`),
|
||||
`None` otherwise (the caller keeps its own reply, e.g. the support phrase)."""
|
||||
if ctx.text is None:
|
||||
return None
|
||||
if DOSE_QUESTION.search(ctx.text.lower()):
|
||||
log.info("kb: dose question redirected to doctor")
|
||||
return load_knowledge_texts().dose_redirect
|
||||
# Tool-using agent first (RAG + ЕМИАС record + drug-safety check); disabled/failed → extractive RAG below.
|
||||
smart = await agent.answer_chat(ctx.token, ctx.text)
|
||||
if smart is not None:
|
||||
log.info("kb: agent answered provider=%s tools=%s", smart.provider, ",".join(smart.tools))
|
||||
return agent.render(smart)
|
||||
reply = await rag.answer(ctx.text, audience="patient")
|
||||
if reply is not None:
|
||||
log.info("kb: answered docs=%s", ",".join(c.doc for c in reply.citations))
|
||||
return reply.text
|
||||
log.info("kb: no answer explicit=%s", explicit)
|
||||
return rag.fallback_text("patient") if explicit else None
|
||||
|
||||
|
||||
@trigger("button:menu:kb_question")
|
||||
async def _menu_question(ctx: Ctx, event: Event) -> Step:
|
||||
return Step(replies=[Reply(text=load_knowledge_texts().prompt)], next_state=QUESTION_STATE)
|
||||
|
||||
|
||||
@state(QUESTION_STATE)
|
||||
async def _question(ctx: Ctx, event: Event) -> Step:
|
||||
if event.type != "text" or ctx.text is None:
|
||||
# A menu button or a reminder instead of the question: drop the question and let idle handle it.
|
||||
step = Step(next_state="idle")
|
||||
idle = handler_for("idle")
|
||||
return step.then(await idle(ctx, event)) if idle is not None else step
|
||||
text = await knowledge_answer(ctx, explicit=True)
|
||||
return Step(replies=[menu_reply(ctx, text)], next_state="idle")
|
||||
|
||||
|
||||
# A question asked yesterday must not swallow today's message.
|
||||
abandonable("kb")
|
||||
@@ -42,7 +42,8 @@ from app.dialog.contracts import Button, Event, Reply
|
||||
from app.dialog.flows.core import menu_reply
|
||||
from app.dialog.fsm import Ctx, Step, abandonable, get_trigger, handler_for, state, trigger, trigger_payload
|
||||
from app.integrations.base import integrations
|
||||
from app.llm.med_qa import fallback_text, med_qa
|
||||
from app.llm import agent
|
||||
from app.llm.med_qa import DOSE_QUESTION, fallback_text, med_qa
|
||||
|
||||
QUESTION_STATE = "meds.question"
|
||||
SIDE_EFFECT_TEXT_STATE = "meds.side_effect_text"
|
||||
@@ -441,6 +442,11 @@ async def answer_question(ctx: Ctx, rx: Rx | None) -> str:
|
||||
"""Answer from the instruction excerpt only (SPEC §7 п.5); dose questions and gaps → «уточните у врача»."""
|
||||
if rx is None or ctx.text is None:
|
||||
return load_meds_texts().question.no_prescription
|
||||
if DOSE_QUESTION.search(ctx.text.lower()) is None:
|
||||
# Agent: instruction + ЕМИАС record (other drugs, conditions, intolerances) + guidelines; else excerpt only.
|
||||
smart = await agent.answer_chat(ctx.token, ctx.text)
|
||||
if smart is not None:
|
||||
return agent.render(smart)
|
||||
answer = await med_qa(rx.drug, ctx.text)
|
||||
return answer.text if answer is not None else fallback_text()
|
||||
|
||||
|
||||
@@ -47,6 +47,7 @@ from app.db import repo
|
||||
from app.dialog.contracts import Button, Event, Reply
|
||||
from app.dialog.flows import intake
|
||||
from app.dialog.flows.core import menu_reply
|
||||
from app.dialog.flows.knowledge import knowledge_answer, looks_like_question
|
||||
from app.dialog.flows.meds import (
|
||||
answer_question,
|
||||
checkin_of,
|
||||
@@ -423,11 +424,13 @@ async def _visit(ctx: Ctx, event: Event) -> Step:
|
||||
@trigger("text:idle", replace=True)
|
||||
async def _idle_text(ctx: Ctx, event: Event) -> Step:
|
||||
"""Free text outside the check-in: drug question → instruction excerpt; side effects / quit intent / alcohol
|
||||
→ today's check-in (the rules react); otherwise the neutral support phrase with the menu."""
|
||||
→ today's check-in (the rules react); another question → clinical guidelines (knowledge base); otherwise
|
||||
the neutral support phrase with the menu."""
|
||||
assert ctx.text is not None
|
||||
facts = await ctx.gateway.extract_checkin(ctx.text)
|
||||
if facts is None:
|
||||
return Step(replies=[menu_reply(ctx, await ctx.gateway.phrase("support"))])
|
||||
text = await knowledge_answer(ctx, explicit=False) if looks_like_question(ctx.text) else None
|
||||
return Step(replies=[menu_reply(ctx, text or await ctx.gateway.phrase("support"))])
|
||||
fields: dict[str, Any] = {}
|
||||
if facts.quit_intent:
|
||||
fields["quit_intent"] = True
|
||||
@@ -445,6 +448,8 @@ async def _idle_text(ctx: Ctx, event: Event) -> Step:
|
||||
await save_checkin(ctx, **fields)
|
||||
if text is None and facts.med_question and not facts.quit_intent:
|
||||
text = await answer_question(ctx, await current_prescription(ctx))
|
||||
if text is None and not fields and looks_like_question(ctx.text):
|
||||
text = await knowledge_answer(ctx, explicit=False) # general question → clinical guidelines (#64)
|
||||
if text is None:
|
||||
text = await ctx.gateway.phrase("support")
|
||||
return Step(replies=[menu_reply(ctx, text)], notify_monitoring=bool(fields or facts.side_effects))
|
||||
|
||||
@@ -47,6 +47,7 @@ class AgeGateTexts(_Strict):
|
||||
class IdleButtons(_Strict):
|
||||
checkin: str
|
||||
med_question: str
|
||||
kb_question: str
|
||||
contact_doctor: str
|
||||
revoke: str
|
||||
|
||||
|
||||
@@ -0,0 +1,51 @@
|
||||
"""Demo adapters behind the frozen integration Protocols (SPEC §9, #14).
|
||||
|
||||
`setup()` runs when the package is first imported. Every consumer imports `app.integrations.base`, which
|
||||
initialises this package first, and `app/main.py` is a frozen contract — so the registry is wired before
|
||||
any request or job without a startup hook. Setup only constructs objects: data files and DB sessions are
|
||||
opened lazily on the first call, so importing the package never fails on I/O.
|
||||
|
||||
Registry after setup:
|
||||
- `prescriptions` — `MisMock`: clinical DB `prescriptions`, then `data/meds/mis_prescriptions.json`;
|
||||
- `identity` — `ConnectCodeIdentity`: one-time connect code from the doctor (ЕСИА stand-in);
|
||||
- `drug_info` — `GrlsExcerpts`: `data/meds/grls/*.yaml`;
|
||||
- `notifier` — `CompositeNotifier`: in-memory dashboard feed + optional Telegram doctor chat;
|
||||
- `outbox` — unchanged `MemoryOutbox` (the web console drains it; the Telegram channel wraps it at start).
|
||||
"""
|
||||
|
||||
from app.integrations.base import (
|
||||
EmptyPrescriptions,
|
||||
MemoryNotifier,
|
||||
NoDrugInfo,
|
||||
RejectIdentity,
|
||||
integrations,
|
||||
)
|
||||
from app.integrations.connect_code import ConnectCodeIdentity
|
||||
from app.integrations.grls import GrlsExcerpts
|
||||
from app.integrations.mis_mock import MisMock
|
||||
from app.integrations.notify import CompositeNotifier, NotificationFeed
|
||||
|
||||
__all__ = ["CompositeNotifier", "ConnectCodeIdentity", "GrlsExcerpts", "MisMock", "NotificationFeed", "setup"]
|
||||
|
||||
_done = False
|
||||
|
||||
|
||||
def setup(*, force: bool = False) -> None:
|
||||
"""Register the demo adapters. Idempotent; never replaces an adapter someone already swapped in
|
||||
(a test fake, the Telegram outbox), only the in-memory defaults from `base.py` — unless `force`."""
|
||||
global _done
|
||||
if _done and not force:
|
||||
return
|
||||
if force or isinstance(integrations.prescriptions, EmptyPrescriptions):
|
||||
integrations.prescriptions = MisMock()
|
||||
if force or isinstance(integrations.identity, RejectIdentity):
|
||||
integrations.identity = ConnectCodeIdentity()
|
||||
if force or isinstance(integrations.drug_info, NoDrugInfo):
|
||||
integrations.drug_info = GrlsExcerpts()
|
||||
# Exact type check: MemoryNotifier subclasses used as test sinks must stay in place.
|
||||
if force or type(integrations.notifier) is MemoryNotifier:
|
||||
integrations.notifier = CompositeNotifier()
|
||||
_done = True
|
||||
|
||||
|
||||
setup()
|
||||
|
||||
@@ -0,0 +1,58 @@
|
||||
"""ЕСИА stand-in: the patient proves identity with the one-time connect code issued by the doctor.
|
||||
|
||||
The doctor creates the code in «Подключить пациента» (identity DB `connect_codes`); the patient opens the
|
||||
QR deep link / enters the code. In prod this is ЕСИА OAuth; the `IdentityProvider` Protocol stays the same.
|
||||
"""
|
||||
|
||||
import logging
|
||||
from datetime import UTC, timedelta
|
||||
|
||||
from sqlalchemy.exc import SQLAlchemyError
|
||||
|
||||
from app.core import clock
|
||||
from app.integrations.base import VerifiedPerson
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
# One connect flow verifies the same code twice: the Telegram channel on `/start <code>` (to bind the chat)
|
||||
# and then the dialog engine's `new` state (to check the code belongs to this token). A short grace window
|
||||
# lets the second check pass; after it a used code is rejected like an unknown one.
|
||||
REDEEM_GRACE = timedelta(minutes=15)
|
||||
|
||||
|
||||
class ConnectCodeIdentity:
|
||||
"""`IdentityProvider` over identity-DB connect codes."""
|
||||
|
||||
def __init__(self, grace: timedelta = REDEEM_GRACE) -> None:
|
||||
self.grace = grace
|
||||
|
||||
async def verify(self, auth_code: str) -> VerifiedPerson | None:
|
||||
code = auth_code.strip()
|
||||
if not code:
|
||||
return None
|
||||
# Imported lazily: the integrations package is imported by clinical-side modules, which must not
|
||||
# pull the identity schema into their import graph (guardrail #5).
|
||||
from app.db import identity_repo
|
||||
from app.db.identity import ConnectCode
|
||||
from app.db.session import get_identity_session
|
||||
|
||||
now = clock.now()
|
||||
try:
|
||||
async with get_identity_session() as s:
|
||||
row = await s.get(ConnectCode, code)
|
||||
if row is None:
|
||||
log.info("connect code rejected: unknown")
|
||||
return None
|
||||
person = VerifiedPerson(token=row.token, doctor_id=row.doctor_id)
|
||||
if row.used_at is not None:
|
||||
used_at = row.used_at if row.used_at.tzinfo else row.used_at.replace(tzinfo=UTC)
|
||||
if now - used_at <= self.grace:
|
||||
return person
|
||||
log.info("connect code rejected: already used")
|
||||
return None
|
||||
if await identity_repo.redeem_connect_code(s, code=code, now=now) is None:
|
||||
return None
|
||||
return person
|
||||
except (OSError, SQLAlchemyError) as exc:
|
||||
log.warning("connect code check failed error=%s", type(exc).__name__)
|
||||
return None
|
||||
@@ -0,0 +1,94 @@
|
||||
"""ЕМИАС medical record mock: diagnoses, comorbidities, allergies and other specialists' prescriptions.
|
||||
|
||||
Prod: the regional МИС / ЕГИСЗ adapter replaces `EmiasRecordSource` (same `get(token)` contract). Demo: synthetic
|
||||
records from `data/emias/records.yaml` keyed by synthetic SNILS, converted to tokens with `pseudo_id()` at load
|
||||
time — so the record handed to the chat agent carries no SNILS, name or phone (guardrail #1). The current
|
||||
psychiatric prescription comes from the МИС mock (`integrations.prescriptions`).
|
||||
"""
|
||||
|
||||
import logging
|
||||
from functools import lru_cache
|
||||
from pathlib import Path
|
||||
|
||||
import yaml
|
||||
from pydantic import BaseModel, Field
|
||||
|
||||
from app.config import get_settings
|
||||
from app.core.privacy import pseudo_id
|
||||
from app.integrations.base import integrations
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class Diagnosis(BaseModel):
|
||||
code: str
|
||||
name: str
|
||||
|
||||
|
||||
class Condition(BaseModel):
|
||||
name: str
|
||||
tags: list[str] = Field(default_factory=list)
|
||||
|
||||
|
||||
class OtherMedication(BaseModel):
|
||||
drug: str
|
||||
how: str = ""
|
||||
prescribed_by: str = ""
|
||||
classes: list[str] = Field(default_factory=list)
|
||||
|
||||
|
||||
class CurrentPrescription(BaseModel):
|
||||
drug: str
|
||||
dose: str
|
||||
instructions: str = ""
|
||||
|
||||
|
||||
class PatientRecord(BaseModel):
|
||||
"""Clinical-only view of the record (no identifiers): what the chat agent may see."""
|
||||
|
||||
diagnoses: list[Diagnosis] = Field(default_factory=list)
|
||||
conditions: list[Condition] = Field(default_factory=list)
|
||||
allergies: list[Condition] = Field(default_factory=list)
|
||||
other_medications: list[OtherMedication] = Field(default_factory=list)
|
||||
pregnancy: dict[str, str] | None = None
|
||||
current_prescriptions: list[CurrentPrescription] = Field(default_factory=list)
|
||||
|
||||
|
||||
def default_records_path() -> Path:
|
||||
return get_settings().data_dir / "emias" / "records.yaml"
|
||||
|
||||
|
||||
@lru_cache
|
||||
def _load(path: Path) -> dict[str, PatientRecord]:
|
||||
raw = yaml.safe_load(path.read_text(encoding="utf-8")) or {}
|
||||
out: dict[str, PatientRecord] = {}
|
||||
for snils, rec in (raw.get("records") or {}).items():
|
||||
out[pseudo_id(snils)] = PatientRecord.model_validate(rec)
|
||||
return out
|
||||
|
||||
|
||||
class EmiasRecordSource:
|
||||
def __init__(self, path: Path | None = None) -> None:
|
||||
self._path = path
|
||||
|
||||
async def get(self, token: str) -> PatientRecord | None:
|
||||
try:
|
||||
base = _load(self._path or default_records_path()).get(token)
|
||||
except (OSError, yaml.YAMLError, ValueError) as exc:
|
||||
log.error("emias records unavailable: %s", type(exc).__name__)
|
||||
base = None
|
||||
record = base.model_copy(deep=True) if base is not None else PatientRecord()
|
||||
try:
|
||||
rx = await integrations.prescriptions.get_prescriptions(token)
|
||||
except Exception as exc: # noqa: BLE001 — the МИС being down must not break the chat
|
||||
log.error("prescriptions unavailable: %s", type(exc).__name__)
|
||||
rx = []
|
||||
record.current_prescriptions = [
|
||||
CurrentPrescription(drug=p.drug, dose=p.dose, instructions=p.instructions) for p in rx
|
||||
]
|
||||
if base is None and not rx:
|
||||
return None
|
||||
return record
|
||||
|
||||
|
||||
emias_records = EmiasRecordSource()
|
||||
@@ -0,0 +1,80 @@
|
||||
"""ГРЛС stand-in: short excerpts of the official drug instruction, per section (SPEC §9, SPEC §7 п.5).
|
||||
|
||||
Each `data/meds/grls/<name>.yaml` holds one drug:
|
||||
|
||||
inn: сертралин
|
||||
aliases: [sertraline]
|
||||
sections:
|
||||
side_effects: {text: "...", source: "ГРЛС, инструкция по медицинскому применению, раздел «...»"}
|
||||
|
||||
Section codes are the ones `app/llm/med_qa.py` understands (side_effects, onset, alcohol, discontinuation,
|
||||
administration, interactions, overdose). The bot answers drug questions ONLY from these texts, so they are
|
||||
the single place to verify against the current ГРЛС instruction (see the header of each file).
|
||||
"""
|
||||
|
||||
import logging
|
||||
from pathlib import Path
|
||||
|
||||
import yaml
|
||||
from pydantic import BaseModel, Field, ValidationError
|
||||
|
||||
from app.config import get_settings
|
||||
from app.integrations.base import DrugSection
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class _SectionFile(BaseModel):
|
||||
text: str
|
||||
source: str
|
||||
|
||||
|
||||
class _DrugFile(BaseModel):
|
||||
inn: str
|
||||
aliases: list[str] = Field(default_factory=list)
|
||||
sections: dict[str, _SectionFile]
|
||||
|
||||
|
||||
def default_grls_dir() -> Path:
|
||||
return get_settings().data_dir / "meds" / "grls"
|
||||
|
||||
|
||||
def normalize_inn(name: str) -> str:
|
||||
"""Lookup key: «Сертралин 50 мг», «сертралин», «Sertraline» -> first word, lower case, ё -> е."""
|
||||
words = name.strip().lower().replace("ё", "е").split()
|
||||
return words[0] if words else ""
|
||||
|
||||
|
||||
class GrlsExcerpts:
|
||||
"""`DrugInfo` over local YAML excerpts. Files are read lazily on the first lookup and cached."""
|
||||
|
||||
def __init__(self, directory: Path | None = None) -> None:
|
||||
self._dir = directory
|
||||
self._index: dict[str, list[DrugSection]] | None = None
|
||||
|
||||
def _load(self) -> dict[str, list[DrugSection]]:
|
||||
if self._index is not None:
|
||||
return self._index
|
||||
directory = self._dir or default_grls_dir()
|
||||
index: dict[str, list[DrugSection]] = {}
|
||||
for path in sorted(directory.glob("*.yaml")):
|
||||
try:
|
||||
drug = _DrugFile.model_validate(yaml.safe_load(path.read_text(encoding="utf-8")))
|
||||
except (OSError, yaml.YAMLError, ValidationError) as exc:
|
||||
log.warning("grls file skipped file=%s error=%s", path.name, type(exc).__name__)
|
||||
continue
|
||||
sections = [
|
||||
DrugSection(inn=drug.inn, section=code, text=" ".join(s.text.split()), source=s.source)
|
||||
for code, s in drug.sections.items()
|
||||
]
|
||||
for key in (drug.inn, *drug.aliases):
|
||||
index[normalize_inn(key)] = sections
|
||||
self._index = index
|
||||
return index
|
||||
|
||||
def known(self) -> list[str]:
|
||||
"""INNs with excerpts (for the dashboard / tests)."""
|
||||
return sorted({s[0].inn for s in self._load().values() if s})
|
||||
|
||||
async def sections(self, inn: str) -> list[DrugSection]:
|
||||
return [s.model_copy() for s in self._load().get(normalize_inn(inn), [])]
|
||||
@@ -0,0 +1,97 @@
|
||||
"""МИС / ЕГИСЗ stand-in: the patient's prescriptions (SPEC §9).
|
||||
|
||||
Source order: the clinical DB table `prescriptions` (written when the doctor connects a patient or by the
|
||||
demo seed), then the synthetic catalogue `data/meds/mis_prescriptions.json` keyed by token. In prod this is
|
||||
a regional МИС query; the Protocol stays the same.
|
||||
"""
|
||||
|
||||
import json
|
||||
import logging
|
||||
from datetime import date
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
|
||||
from pydantic import BaseModel, Field, ValidationError
|
||||
from sqlalchemy import select
|
||||
from sqlalchemy.exc import SQLAlchemyError
|
||||
|
||||
from app.config import get_settings
|
||||
from app.integrations.base import Prescription
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class _CatalogPatient(BaseModel):
|
||||
persona: str
|
||||
tokens: list[str] = Field(default_factory=list)
|
||||
prescriptions: list[Prescription]
|
||||
|
||||
|
||||
class _Catalog(BaseModel):
|
||||
patients: list[_CatalogPatient]
|
||||
|
||||
|
||||
def _from_row(drug: str, dose: str, schedule: dict[str, Any], start: date | None, end: date | None) -> Prescription:
|
||||
# The table has no instructions column; the doctor's note («утром после еды») may ride in the schedule JSON.
|
||||
times = {k: [str(x) for x in v] for k, v in schedule.items() if isinstance(v, list)}
|
||||
return Prescription(
|
||||
drug=drug,
|
||||
dose=dose,
|
||||
schedule=times or {"times": ["08:00"]},
|
||||
instructions=str(schedule.get("instructions") or ""),
|
||||
start_date=start,
|
||||
end_date=end,
|
||||
)
|
||||
|
||||
|
||||
def default_catalog_path() -> Path:
|
||||
return get_settings().data_dir / "meds" / "mis_prescriptions.json"
|
||||
|
||||
|
||||
class MisMock:
|
||||
"""`PrescriptionSource`: clinical DB first, synthetic JSON catalogue as the fallback."""
|
||||
|
||||
def __init__(self, catalog_path: Path | None = None, *, use_db: bool = True) -> None:
|
||||
self._path = catalog_path
|
||||
self._use_db = use_db
|
||||
self._by_token: dict[str, list[Prescription]] | None = None
|
||||
|
||||
def _catalog(self) -> dict[str, list[Prescription]]:
|
||||
# Lazy: the package is imported before startup, a missing/broken file must not break the import.
|
||||
if self._by_token is None:
|
||||
path = self._path or default_catalog_path()
|
||||
index: dict[str, list[Prescription]] = {}
|
||||
try:
|
||||
catalog = _Catalog.model_validate(json.loads(path.read_text(encoding="utf-8")))
|
||||
except (OSError, ValueError, ValidationError) as exc:
|
||||
log.warning("mis_mock catalogue not loaded error=%s", type(exc).__name__)
|
||||
catalog = _Catalog(patients=[])
|
||||
for patient in catalog.patients:
|
||||
for token in patient.tokens:
|
||||
index[token] = patient.prescriptions
|
||||
self._by_token = index
|
||||
return self._by_token
|
||||
|
||||
async def _from_db(self, token: str) -> list[Prescription]:
|
||||
from app.db.clinical import Prescription as PrescriptionRow
|
||||
from app.db.session import get_clinical_session
|
||||
|
||||
async with get_clinical_session() as s:
|
||||
rows = (
|
||||
await s.scalars(
|
||||
select(PrescriptionRow).where(PrescriptionRow.token == token).order_by(PrescriptionRow.id)
|
||||
)
|
||||
).all()
|
||||
return [_from_row(r.drug, r.dose, r.schedule or {}, r.start_date, r.end_date) for r in rows]
|
||||
|
||||
async def get_prescriptions(self, token: str) -> list[Prescription]:
|
||||
if self._use_db:
|
||||
try:
|
||||
found = await self._from_db(token)
|
||||
except (OSError, SQLAlchemyError) as exc:
|
||||
# DB down or not migrated: the demo still shows the catalogue prescription.
|
||||
log.warning("mis_mock db lookup failed error=%s", type(exc).__name__)
|
||||
found = []
|
||||
if found:
|
||||
return found
|
||||
return [p.model_copy(deep=True) for p in self._catalog().get(token, [])]
|
||||
@@ -0,0 +1,141 @@
|
||||
"""Doctor notifications (SPEC §9): in-memory feed for the dashboard + optional Telegram doctor chat.
|
||||
|
||||
The alert itself is already committed to the clinical DB before `send()` is called (the dashboard reads
|
||||
alerts from there via the API), so every channel here is best effort: failures are logged, never raised.
|
||||
Messages carry only the level, the rule reason/code and a short pseudonymous patient id — no PII
|
||||
(guardrail #8); the reason texts come from `config/rules.yaml`, not from patient messages.
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import itertools
|
||||
import logging
|
||||
from collections import deque
|
||||
from collections.abc import Awaitable, Callable
|
||||
from datetime import datetime
|
||||
from typing import Any
|
||||
|
||||
from pydantic import BaseModel
|
||||
|
||||
from app.config import get_settings
|
||||
from app.core import clock
|
||||
from app.integrations.base import AlertLevelName
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
FEED_SIZE = 500
|
||||
SHORT_ID_LEN = 6
|
||||
MAX_REASON_CHARS = 200
|
||||
TELEGRAM_TIMEOUT_S = 5.0
|
||||
# Doctor-facing labels (not patient texts); acute alerts are visually distinct in the chat.
|
||||
LEVEL_LABELS: dict[str, str] = {
|
||||
"acute": "КРИТИЧНО",
|
||||
"high": "Высокий",
|
||||
"moderate": "Умеренный",
|
||||
"info": "Инфо",
|
||||
}
|
||||
|
||||
ChatSender = Callable[[int, str], Awaitable[Any]]
|
||||
|
||||
|
||||
def short_id(token: str | None) -> str:
|
||||
return token[:SHORT_ID_LEN] if token else "—"
|
||||
|
||||
|
||||
def format_message(level: str, text: str, token: str | None) -> str:
|
||||
reason = " ".join(text.split())
|
||||
if len(reason) > MAX_REASON_CHARS:
|
||||
reason = reason[: MAX_REASON_CHARS - 1] + "…"
|
||||
return f"[{LEVEL_LABELS.get(level, level)}] {reason}\nПациент #{short_id(token)}"
|
||||
|
||||
|
||||
class Notification(BaseModel):
|
||||
id: int
|
||||
ts: datetime
|
||||
doctor_id: str
|
||||
level: str
|
||||
text: str
|
||||
token: str | None = None
|
||||
|
||||
|
||||
class NotificationFeed:
|
||||
"""Bounded in-memory feed; ids increase monotonically so a poller asks only for `recent(since_id)`."""
|
||||
|
||||
def __init__(self, size: int = FEED_SIZE) -> None:
|
||||
self._items: deque[Notification] = deque(maxlen=size)
|
||||
self._ids = itertools.count(1)
|
||||
|
||||
def add(self, doctor_id: str, level: str, text: str, token: str | None, ts: datetime) -> Notification:
|
||||
item = Notification(id=next(self._ids), ts=ts, doctor_id=doctor_id, level=level, text=text, token=token)
|
||||
self._items.append(item)
|
||||
return item
|
||||
|
||||
def recent(self, since_id: int = 0, doctor_id: str | None = None) -> list[Notification]:
|
||||
return [n for n in self._items if n.id > since_id and (doctor_id is None or n.doctor_id == doctor_id)]
|
||||
|
||||
|
||||
class TelegramDoctorChat:
|
||||
"""Sends to the doctor chat `DOCTOR_NOTIFY_CHAT_ID` through the bot `TG_BOT_TOKEN`.
|
||||
|
||||
The aiogram `Bot` is created on the first message only; with either setting empty the channel is off.
|
||||
"""
|
||||
|
||||
def __init__(self, chat_id: int | None = None, bot_token: str | None = None, sender: ChatSender | None = None):
|
||||
settings = get_settings()
|
||||
self.chat_id = chat_id if chat_id is not None else settings.doctor_notify_chat_id
|
||||
self._bot_token = bot_token if bot_token is not None else settings.tg_bot_token
|
||||
self._sender = sender
|
||||
self._bot: Any = None
|
||||
|
||||
@property
|
||||
def enabled(self) -> bool:
|
||||
return self.chat_id is not None and (self._sender is not None or bool(self._bot_token))
|
||||
|
||||
def _get_sender(self) -> ChatSender:
|
||||
if self._sender is None:
|
||||
from aiogram import Bot
|
||||
|
||||
self._bot = Bot(self._bot_token)
|
||||
self._sender = self._bot.send_message
|
||||
return self._sender
|
||||
|
||||
async def send(self, level: str, text: str, token: str | None) -> None:
|
||||
if not self.enabled or self.chat_id is None:
|
||||
return
|
||||
try:
|
||||
await asyncio.wait_for(
|
||||
self._get_sender()(self.chat_id, format_message(level, text, token)), timeout=TELEGRAM_TIMEOUT_S
|
||||
)
|
||||
except Exception as exc: # noqa: BLE001 — any channel error; the alert is already in the DB
|
||||
err = type(exc).__name__
|
||||
log.warning("doctor chat notify failed level=%s tok=%s error=%s", level, short_id(token), err)
|
||||
|
||||
async def aclose(self) -> None:
|
||||
if self._bot is not None:
|
||||
await self._bot.session.close()
|
||||
self._bot = None
|
||||
self._sender = None
|
||||
|
||||
|
||||
class CompositeNotifier:
|
||||
"""`Notifier`: dashboard feed + Telegram doctor chat (when configured)."""
|
||||
|
||||
def __init__(self, feed: NotificationFeed | None = None, chat: TelegramDoctorChat | None = None) -> None:
|
||||
self.feed = feed or NotificationFeed()
|
||||
self._chat = chat
|
||||
|
||||
@property
|
||||
def chat(self) -> TelegramDoctorChat:
|
||||
# Lazy: settings are read on the first notification, not when the package is imported.
|
||||
if self._chat is None:
|
||||
self._chat = TelegramDoctorChat()
|
||||
return self._chat
|
||||
|
||||
def recent(self, since_id: int = 0, doctor_id: str | None = None) -> list[Notification]:
|
||||
return self.feed.recent(since_id, doctor_id)
|
||||
|
||||
async def send(self, doctor_id: str, level: AlertLevelName, text: str, token: str | None = None) -> None:
|
||||
try:
|
||||
self.feed.add(doctor_id, level, text, token, clock.now())
|
||||
except Exception as exc: # noqa: BLE001 — never break the caller
|
||||
log.warning("notify feed failed error=%s", type(exc).__name__)
|
||||
await self.chat.send(level, text, token)
|
||||
@@ -0,0 +1,151 @@
|
||||
"""Chat agent: tool-using LLM over the knowledge base (RAG), the ЕМИАС record and the drug-safety reference.
|
||||
|
||||
from app.llm.agent import answer_chat
|
||||
reply = await answer_chat(token, scrubbed_question) # None → caller falls back to extractive RAG / med_qa
|
||||
|
||||
Guarantees (on top of what the dialog engine already did — scrub, consent, safety check; ACUTE never gets here):
|
||||
* only scrubbed text goes to the provider (`assert_scrubbed`), tool results carry no identifiers;
|
||||
* tools are bound to the current token server-side; read-only;
|
||||
* the final text passes the gateway's forbidden-output filter (diagnoses, dose/drug advice); a violation or any
|
||||
provider error → None, so the patient gets the safe extractive answer instead;
|
||||
* logs carry tool names and counts only.
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import json
|
||||
import logging
|
||||
from typing import Any
|
||||
|
||||
from pydantic import BaseModel
|
||||
|
||||
from app.config import Settings, get_settings
|
||||
from app.core.types import ScrubbedText
|
||||
from app.llm.agent.prompts import SYSTEM_PROMPT
|
||||
from app.llm.agent.providers import (
|
||||
MockAgentProvider,
|
||||
OpenRouterProvider,
|
||||
ProviderError,
|
||||
ToolChatProvider,
|
||||
)
|
||||
from app.llm.agent.tools import TOOL_SPECS, ToolContext, run_tool
|
||||
from app.llm.gateway import is_forbidden
|
||||
from app.llm.guard import assert_scrubbed
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
MAX_ANSWER_CHARS = 1200
|
||||
NUDGE = "Сформулируй ответ пациенту по результатам инструментов выше (3–6 предложений)."
|
||||
_ALLOWED_MSG_KEYS = {"role", "content", "tool_calls", "tool_call_id"}
|
||||
|
||||
|
||||
class AgentAnswer(BaseModel):
|
||||
text: str
|
||||
sources: list[str]
|
||||
tools: list[str]
|
||||
provider: str
|
||||
|
||||
|
||||
def build_provider(settings: Settings | None = None) -> ToolChatProvider | None:
|
||||
s = settings or get_settings()
|
||||
mode = s.chat_agent
|
||||
if mode == "auto":
|
||||
mode = "openrouter" if s.openrouter_api_key else "off"
|
||||
if mode == "openrouter":
|
||||
if not s.openrouter_api_key:
|
||||
log.warning("chat agent: openrouter selected without OPENROUTER_API_KEY — disabled")
|
||||
return None
|
||||
return OpenRouterProvider(s)
|
||||
if mode == "mock":
|
||||
return MockAgentProvider()
|
||||
if mode == "gigachat":
|
||||
# TODO(GigaChat): function calling via the `gigachat` package (functions=..., message.function_call).
|
||||
log.warning("chat agent: gigachat provider not implemented yet — disabled")
|
||||
return None
|
||||
return None
|
||||
|
||||
|
||||
async def _patient_brief(ctx: ToolContext) -> str:
|
||||
"""One line of context so the model knows what «мои таблетки» means (drug names only, no identifiers)."""
|
||||
rec = await ctx.record()
|
||||
if rec is None or not rec.current_prescriptions:
|
||||
return "\n\nТекущее назначение психиатра: нет данных."
|
||||
drugs = ", ".join(p.drug for p in rec.current_prescriptions)
|
||||
return f"\n\nТекущее назначение психиатра: {drugs}. «Мои таблетки» = это назначение."
|
||||
|
||||
|
||||
def _wire(messages: list[dict[str, Any]]) -> list[dict[str, Any]]:
|
||||
"""Strip internal keys (tool `name`) before sending."""
|
||||
return [{k: v for k, v in m.items() if k in _ALLOWED_MSG_KEYS} for m in messages]
|
||||
|
||||
|
||||
async def answer_chat(
|
||||
token: str, question: ScrubbedText, *, provider: ToolChatProvider | None = None, settings: Settings | None = None
|
||||
) -> AgentAnswer | None:
|
||||
s = settings or get_settings()
|
||||
provider = provider or build_provider(s)
|
||||
if provider is None:
|
||||
return None
|
||||
try:
|
||||
assert_scrubbed(question)
|
||||
except ValueError:
|
||||
log.warning("chat agent: unscrubbed input rejected")
|
||||
return None
|
||||
ctx = ToolContext(token=token)
|
||||
messages: list[dict[str, Any]] = [
|
||||
{"role": "system", "content": SYSTEM_PROMPT + await _patient_brief(ctx)},
|
||||
{"role": "user", "content": str(question)},
|
||||
]
|
||||
nudged = False
|
||||
try:
|
||||
async with asyncio.timeout(s.chat_agent_timeout_s * 2):
|
||||
for _ in range(s.chat_agent_max_steps):
|
||||
turn = await provider.chat(_wire(messages) if provider.name != "mock" else messages, TOOL_SPECS)
|
||||
if not turn.tool_calls:
|
||||
if not (turn.content or "").strip() and not nudged:
|
||||
# Some models (Gemini Flash) occasionally end with an empty message after tool results.
|
||||
nudged = True
|
||||
messages.append({"role": "user", "content": NUDGE})
|
||||
continue
|
||||
return _finish(turn.content or "", ctx, provider.name)
|
||||
messages.append(
|
||||
{
|
||||
"role": "assistant",
|
||||
"content": turn.content,
|
||||
"tool_calls": [
|
||||
{
|
||||
"id": c.id,
|
||||
"type": "function",
|
||||
"function": {"name": c.name, "arguments": json.dumps(c.arguments, ensure_ascii=False)},
|
||||
}
|
||||
for c in turn.tool_calls
|
||||
],
|
||||
}
|
||||
)
|
||||
for c in turn.tool_calls:
|
||||
result = await run_tool(ctx, c.name, c.arguments)
|
||||
messages.append({"role": "tool", "tool_call_id": c.id, "name": c.name, "content": result})
|
||||
log.warning("chat agent: step limit reached tools=%s", ",".join(ctx.used))
|
||||
return None
|
||||
except (ProviderError, TimeoutError) as exc:
|
||||
log.error("chat agent provider=%s failed: %s", provider.name, type(exc).__name__ or "timeout")
|
||||
return None
|
||||
|
||||
|
||||
def _finish(text: str, ctx: ToolContext, provider: str) -> AgentAnswer | None:
|
||||
text = text.strip()
|
||||
if not text:
|
||||
return None
|
||||
if is_forbidden(text):
|
||||
log.warning("chat agent: forbidden output filtered provider=%s", provider)
|
||||
return None
|
||||
if len(text) > MAX_ANSWER_CHARS:
|
||||
text = text[:MAX_ANSWER_CHARS].rsplit(" ", 1)[0] + "…"
|
||||
log.info("chat agent ok provider=%s tools=%s sources=%d", provider, ",".join(ctx.used), len(ctx.sources))
|
||||
return AgentAnswer(text=text, sources=ctx.sources[:4], tools=ctx.used, provider=provider)
|
||||
|
||||
|
||||
def render(answer: AgentAnswer) -> str:
|
||||
"""Patient-facing text: answer + short sources footer."""
|
||||
if not answer.sources:
|
||||
return answer.text
|
||||
return f"{answer.text}\n\nИсточники: " + "; ".join(answer.sources)
|
||||
@@ -0,0 +1,59 @@
|
||||
"""Try the chat agent from the shell (synthetic personas only):
|
||||
|
||||
uv run python -m app.llm.agent "Можно мне ибупрофен вместе с моими таблетками?" --persona andrey
|
||||
CHAT_AGENT=mock uv run python -m app.llm.agent "Есть ли лактоза в сертралине?"
|
||||
|
||||
Prescriptions come from the МИС mock (DB if reachable, else data/meds/mis_prescriptions.json); the question is
|
||||
scrubbed before it reaches any provider.
|
||||
"""
|
||||
|
||||
import argparse
|
||||
import asyncio
|
||||
import logging
|
||||
|
||||
from app.config import get_settings
|
||||
from app.core.privacy import pseudo_id, scrub
|
||||
from app.integrations.base import Prescription, integrations
|
||||
from app.llm.agent import answer_chat, build_provider, render
|
||||
|
||||
PERSONAS = { # synthetic SNILS from scripts/seed_demo.py → current psychiatric prescription
|
||||
"andrey": ("900-000-013 34", "сертралин"),
|
||||
"dmitry": ("900-000-041 01", "сертралин"),
|
||||
"sergey": ("900-000-037 02", "пароксетин"),
|
||||
"nikolay": ("900-000-052 03", "сертралин"),
|
||||
"anna": ("900-000-023 04", "флуоксетин"),
|
||||
"pavel": ("900-000-045 07", "эсциталопрам"),
|
||||
}
|
||||
|
||||
|
||||
class _FixedRx:
|
||||
def __init__(self, drug: str) -> None:
|
||||
self.drug = drug
|
||||
|
||||
async def get_prescriptions(self, token: str) -> list[Prescription]:
|
||||
return [Prescription(drug=self.drug, dose="по назначению врача")]
|
||||
|
||||
|
||||
async def main() -> None:
|
||||
p = argparse.ArgumentParser()
|
||||
p.add_argument("question")
|
||||
p.add_argument("--persona", default="andrey", choices=sorted(PERSONAS))
|
||||
p.add_argument("-v", "--verbose", action="store_true")
|
||||
a = p.parse_args()
|
||||
logging.basicConfig(level=logging.INFO if a.verbose else logging.WARNING)
|
||||
snils, drug = PERSONAS[a.persona]
|
||||
integrations.prescriptions = _FixedRx(drug) # CLI runs without the DB
|
||||
provider = build_provider()
|
||||
if provider is None:
|
||||
raise SystemExit(
|
||||
f"agent disabled (CHAT_AGENT={get_settings().chat_agent}); set OPENROUTER_API_KEY or CHAT_AGENT=mock"
|
||||
)
|
||||
ans = await answer_chat(pseudo_id(snils), scrub(a.question), provider=provider)
|
||||
if ans is None:
|
||||
raise SystemExit("no answer (provider error, filtered output or nothing found) — chat falls back to RAG")
|
||||
print(render(ans))
|
||||
print(f"\n[provider={ans.provider} tools={', '.join(ans.tools)}]")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
asyncio.run(main())
|
||||
@@ -0,0 +1,147 @@
|
||||
"""Deterministic drug-safety lookup: composition, contraindications, interactions, patient-specific findings.
|
||||
|
||||
The LLM never decides whether a drug is safe for the patient (ADR-007 spirit): it calls `check_patient` and
|
||||
retells the findings. Matching is by tags shared with the ЕМИАС record (`data/emias/records.yaml`):
|
||||
condition tags → `cautions[].when_condition`, allergy tags → `composition.excipient_tags`, other medication
|
||||
classes → `interactions[].with_class`. Source data: `data/meds/drug_safety.yaml` (prototype retelling of ГРЛС).
|
||||
"""
|
||||
|
||||
from functools import lru_cache
|
||||
from pathlib import Path
|
||||
from typing import Literal
|
||||
|
||||
import yaml
|
||||
from pydantic import BaseModel, Field
|
||||
|
||||
from app.config import get_settings
|
||||
from app.integrations.emias_record import PatientRecord
|
||||
|
||||
Severity = Literal["high", "medium", "low"]
|
||||
|
||||
|
||||
class Caution(BaseModel):
|
||||
when_condition: str
|
||||
severity: Severity
|
||||
text: str
|
||||
|
||||
|
||||
class Interaction(BaseModel):
|
||||
with_class: str
|
||||
severity: Severity
|
||||
text: str
|
||||
|
||||
|
||||
class Composition(BaseModel):
|
||||
form: str
|
||||
active: str
|
||||
excipients: list[str] = Field(default_factory=list)
|
||||
excipient_tags: list[str] = Field(default_factory=list)
|
||||
note: str = ""
|
||||
|
||||
|
||||
class DrugEntry(BaseModel):
|
||||
inn: str
|
||||
aliases: list[str] = Field(default_factory=list)
|
||||
drug_class: str = ""
|
||||
classes: list[str] = Field(default_factory=list) # classes this drug belongs to (e.g. nsaid, ssri)
|
||||
contraindications: list[str] = Field(default_factory=list)
|
||||
cautions: list[Caution] = Field(default_factory=list)
|
||||
interactions: list[Interaction] = Field(default_factory=list)
|
||||
composition: Composition | None = None
|
||||
pregnancy: str = ""
|
||||
source: str = ""
|
||||
|
||||
|
||||
class Finding(BaseModel):
|
||||
severity: Severity
|
||||
kind: Literal["condition", "allergy", "interaction", "pregnancy", "contraindication"]
|
||||
text: str
|
||||
|
||||
|
||||
class SafetyDb(BaseModel):
|
||||
drugs: dict[str, DrugEntry]
|
||||
allergy_labels: dict[str, str] = Field(default_factory=dict)
|
||||
|
||||
|
||||
def _path() -> Path:
|
||||
return get_settings().data_dir / "meds" / "drug_safety.yaml"
|
||||
|
||||
|
||||
@lru_cache
|
||||
def load_db(path: Path | None = None) -> SafetyDb:
|
||||
raw = yaml.safe_load((path or _path()).read_text(encoding="utf-8"))
|
||||
classes_of: dict[str, list[str]] = {}
|
||||
for cls, members in (raw.get("drug_classes") or {}).items():
|
||||
for m in members:
|
||||
classes_of.setdefault(m, []).append(cls)
|
||||
drugs: dict[str, DrugEntry] = {}
|
||||
for inn, d in (raw.get("drugs") or {}).items():
|
||||
entry = DrugEntry(
|
||||
inn=inn,
|
||||
aliases=d.get("aliases", []),
|
||||
drug_class=d.get("class", ""),
|
||||
classes=sorted(set(d.get("classes", [])) | set(classes_of.get(inn, []))),
|
||||
contraindications=d.get("contraindications", []),
|
||||
cautions=d.get("cautions", []),
|
||||
interactions=d.get("interactions", []),
|
||||
composition=d.get("composition"),
|
||||
pregnancy=d.get("pregnancy", ""),
|
||||
source=d.get("source", ""),
|
||||
)
|
||||
drugs[inn] = entry
|
||||
return SafetyDb(drugs=drugs, allergy_labels=raw.get("allergy_labels") or {})
|
||||
|
||||
|
||||
def find_drug(name: str, db: SafetyDb | None = None) -> DrugEntry | None:
|
||||
"""By INN or alias, case-insensitive; "сертралин 50 мг" → сертралин."""
|
||||
db = db or load_db()
|
||||
words = [w.strip(".,!?;:«»()") for w in name.lower().replace("ё", "е").split()]
|
||||
for entry in db.drugs.values():
|
||||
names = {entry.inn, *(a.lower() for a in entry.aliases)}
|
||||
# Russian case endings: "сертралине", "ибупрофена" — match on the stem (name minus the last letter).
|
||||
if any(w in names or any(len(n) > 4 and w.startswith(n[:-1]) for n in names) for w in words):
|
||||
return entry
|
||||
return None
|
||||
|
||||
|
||||
def check_patient(drug: DrugEntry, record: PatientRecord, db: SafetyDb | None = None) -> list[Finding]:
|
||||
"""Patient-specific findings for `drug`, most severe first. Empty list = nothing found in the reference —
|
||||
which is NOT a statement that the drug is safe (the answer must say so)."""
|
||||
db = db or load_db()
|
||||
out: list[Finding] = []
|
||||
cond_tags = {t for c in record.conditions for t in c.tags}
|
||||
for c in drug.cautions:
|
||||
if c.when_condition in cond_tags:
|
||||
out.append(Finding(severity=c.severity, kind="condition", text=c.text))
|
||||
# Excipients vs allergies / intolerances.
|
||||
allergy_tags = {t for a in record.allergies for t in a.tags}
|
||||
if drug.composition is not None:
|
||||
for tag in sorted(allergy_tags & set(drug.composition.excipient_tags)):
|
||||
label = db.allergy_labels.get(tag, tag)
|
||||
out.append(
|
||||
Finding(
|
||||
severity="high", kind="allergy", text=f"В составе есть {label}, а в карте отмечена непереносимость."
|
||||
)
|
||||
)
|
||||
# Interactions with the patient's other medicines and with the current psychiatric prescription.
|
||||
other_classes: dict[str, str] = {}
|
||||
for m in record.other_medications:
|
||||
for cls in m.classes:
|
||||
other_classes[cls] = m.drug
|
||||
for rx in record.current_prescriptions:
|
||||
entry = find_drug(rx.drug, db)
|
||||
if entry is not None and entry.inn != drug.inn:
|
||||
for cls in entry.classes:
|
||||
other_classes.setdefault(cls, rx.drug)
|
||||
for i in drug.interactions:
|
||||
if i.with_class in other_classes:
|
||||
out.append(
|
||||
Finding(
|
||||
severity=i.severity, kind="interaction", text=f"{i.text} (в карте: {other_classes[i.with_class]})."
|
||||
)
|
||||
)
|
||||
if record.pregnancy and drug.pregnancy:
|
||||
out.append(Finding(severity="medium", kind="pregnancy", text=drug.pregnancy))
|
||||
order = {"high": 0, "medium": 1, "low": 2}
|
||||
out.sort(key=lambda f: order[f.severity])
|
||||
return out
|
||||
@@ -0,0 +1,31 @@
|
||||
"""System prompt of the chat agent (Russian). Prohibitions follow SPEC §7; grounding: answer only from tools."""
|
||||
|
||||
SYSTEM_PROMPT = """Ты — помощник пациента в сервисе сопровождения лечения между визитами к врачу. Пациент лечится у
|
||||
психиатра; ты отвечаешь на его вопросы о состоянии, лечении и лекарствах.
|
||||
|
||||
Как работать:
|
||||
1. Сначала собери данные инструментами. Для вопросов о лекарствах, сочетаниях, составе, аллергиях всегда
|
||||
вызывай get_patient_record и check_drug_for_patient (для каждого упомянутого препарата и, если вопрос
|
||||
о «моих таблетках», для текущего назначения). Вопросы об алкоголе, еде, вождении, сочетании с другими
|
||||
средствами, составе и непереносимостях — тоже вопросы о лекарстве: проверь текущее назначение через
|
||||
check_drug_for_patient (там есть состав, сравнение с непереносимостями и все взаимодействия).
|
||||
Для общих вопросов о лечении вызывай search_guidelines.
|
||||
2. Отвечай ТОЛЬКО на основе результатов инструментов. Если в них нет ответа — честно скажи, что в
|
||||
рекомендациях и инструкции этого нет, и предложи уточнить у лечащего врача. Ничего не додумывай.
|
||||
3. Если check_drug_for_patient вернул findings — назови КАЖДУЮ находку (сначала severity=high) простыми
|
||||
словами и посоветуй обсудить с врачом до приёма. Пустой список не значит «безопасно».
|
||||
Про состав и непереносимости (intolerance_check) говори, только если о них спросили.
|
||||
Про алкоголь бери текст из general_interactions.
|
||||
4. Ссылайся на источник в тексте коротко: «по клиническим рекомендациям», «по инструкции к препарату»,
|
||||
«в вашей карте указано».
|
||||
|
||||
Запрещено:
|
||||
- ставить или называть диагнозы («у вас депрессия»), даже если они есть в карте;
|
||||
- назначать, отменять препараты, менять дозы, советовать «примите/не принимайте» — решение всегда за врачом;
|
||||
- называть дозировки в миллиграммах;
|
||||
- проводить психотерапию; обещать конфиденциальность сверх реальной;
|
||||
- выдумывать факты, которых нет в результатах инструментов.
|
||||
|
||||
Стиль: по-русски, на «вы», спокойно и по-человечески, 3–6 коротких предложений, без markdown-заголовков.
|
||||
Если в вопросе есть признаки угрозы жизни — коротко скажи, что важно сразу позвонить 112 или на телефон
|
||||
доверия 8-800-2000-122, и что врач будет уведомлён."""
|
||||
@@ -0,0 +1,179 @@
|
||||
"""Tool-calling chat providers for the agent.
|
||||
|
||||
* `OpenRouterProvider` — OpenAI-compatible `/chat/completions` with `tools`. TEMPORARY for the prototype on
|
||||
synthetic data: OpenRouter is a foreign service, forbidden for real PII (152-FZ art. 18 p. 5). Replace with
|
||||
GigaChat (function calling) before any real patient — same `ToolChatProvider` contract.
|
||||
* `MockAgentProvider` — offline, deterministic: plans tool calls from keywords and composes an answer from the
|
||||
tool results. Keeps the demo working without network (ADR-004).
|
||||
"""
|
||||
|
||||
import json
|
||||
import logging
|
||||
import re
|
||||
from typing import Any, Protocol
|
||||
|
||||
import httpx
|
||||
from pydantic import BaseModel, Field
|
||||
|
||||
from app.config import Settings
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class ToolCall(BaseModel):
|
||||
id: str
|
||||
name: str
|
||||
arguments: dict[str, Any] = Field(default_factory=dict)
|
||||
|
||||
|
||||
class AssistantTurn(BaseModel):
|
||||
content: str | None = None
|
||||
tool_calls: list[ToolCall] = Field(default_factory=list)
|
||||
|
||||
|
||||
class ToolChatProvider(Protocol):
|
||||
name: str
|
||||
|
||||
async def chat(self, messages: list[dict[str, Any]], tools: list[dict[str, Any]]) -> AssistantTurn: ...
|
||||
|
||||
|
||||
class ProviderError(RuntimeError):
|
||||
pass
|
||||
|
||||
|
||||
class OpenRouterProvider:
|
||||
name = "openrouter"
|
||||
|
||||
def __init__(self, settings: Settings, client: httpx.AsyncClient | None = None) -> None:
|
||||
self._key = settings.openrouter_api_key
|
||||
self._model = settings.openrouter_model
|
||||
self._url = settings.openrouter_base_url.rstrip("/") + "/chat/completions"
|
||||
self._timeout = settings.chat_agent_timeout_s
|
||||
self._client = client
|
||||
|
||||
async def chat(self, messages: list[dict[str, Any]], tools: list[dict[str, Any]]) -> AssistantTurn:
|
||||
body: dict[str, Any] = {"model": self._model, "messages": messages, "tools": tools, "temperature": 0.1}
|
||||
body["max_tokens"] = 900
|
||||
if not any(m["role"] == "tool" for m in messages):
|
||||
body["tool_choice"] = "required" # never answer from the model's own memory: ground first
|
||||
headers = {"Authorization": f"Bearer {self._key}", "X-Title": "PTSRaiAgent prototype (synthetic data)"}
|
||||
try:
|
||||
if self._client is not None:
|
||||
resp = await self._client.post(self._url, json=body, headers=headers, timeout=self._timeout)
|
||||
else:
|
||||
async with httpx.AsyncClient(timeout=self._timeout) as client:
|
||||
resp = await client.post(self._url, json=body, headers=headers)
|
||||
except httpx.HTTPError as exc:
|
||||
raise ProviderError(type(exc).__name__) from exc
|
||||
if resp.status_code != 200:
|
||||
raise ProviderError(f"http {resp.status_code}")
|
||||
try:
|
||||
msg = resp.json()["choices"][0]["message"]
|
||||
except (ValueError, KeyError, IndexError) as exc:
|
||||
raise ProviderError("bad response") from exc
|
||||
calls = []
|
||||
for c in msg.get("tool_calls") or []:
|
||||
fn = c.get("function") or {}
|
||||
try:
|
||||
args = json.loads(fn.get("arguments") or "{}")
|
||||
except json.JSONDecodeError:
|
||||
args = {}
|
||||
calls.append(ToolCall(id=c.get("id") or fn.get("name", "call"), name=fn.get("name", ""), arguments=args))
|
||||
usage = resp.json().get("usage") or {}
|
||||
log.info("openrouter ok calls=%d tokens=%s", len(calls), usage.get("total_tokens"))
|
||||
return AssistantTurn(content=msg.get("content"), tool_calls=calls)
|
||||
|
||||
|
||||
# ------------------------------------------------------------------------------------------------ offline mock
|
||||
|
||||
_DRUG_WORDS = re.compile(
|
||||
r"\b(сертралин\w*|пароксетин\w*|эсциталопрам\w*|флуоксетин\w*|ибупрофен\w*|нурофен\w*|золофт\w*)", re.I
|
||||
)
|
||||
_MED_HINT = re.compile(r"(таблет|лекарств|препарат|состав|можно ли|совмест|вместе|противопоказ|аллерг|лактоз)", re.I)
|
||||
|
||||
|
||||
class MockAgentProvider:
|
||||
"""Plans: record → (drug check for each mentioned drug, or the current prescription for medicine questions)
|
||||
→ guidelines search; then writes a short answer strictly from the tool results."""
|
||||
|
||||
name = "mock"
|
||||
|
||||
async def chat(self, messages: list[dict[str, Any]], tools: list[dict[str, Any]]) -> AssistantTurn:
|
||||
question = next(m["content"] for m in reversed(messages) if m["role"] == "user")
|
||||
done = [m for m in messages if m["role"] == "tool"]
|
||||
if not done:
|
||||
drugs = [m.group(1).lower() for m in _DRUG_WORDS.finditer(question)]
|
||||
calls = [ToolCall(id="c0", name="get_patient_record")]
|
||||
calls += [
|
||||
ToolCall(id=f"d{i}", name="check_drug_for_patient", arguments={"drug": d}) for i, d in enumerate(drugs)
|
||||
]
|
||||
if drugs and re.search(r"состав|лактоз|желатин|аллерг|непереносим", question, re.I):
|
||||
calls += [
|
||||
ToolCall(id=f"i{i}", name="get_drug_info", arguments={"drug": d}) for i, d in enumerate(drugs)
|
||||
]
|
||||
calls.append(ToolCall(id="s0", name="search_guidelines", arguments={"query": question}))
|
||||
return AssistantTurn(tool_calls=calls)
|
||||
mine = re.search(r"мо(и|ими|их|ей|я|ё) (таблет|лекарств|препарат)", question, re.I)
|
||||
checked = [m for m in done if m.get("name") == "check_drug_for_patient"]
|
||||
if (not checked or mine) and len(checked) < 3 and _MED_HINT.search(question):
|
||||
record = _tool_json(done, "get_patient_record")
|
||||
rx = (record or {}).get("current_prescriptions") or []
|
||||
checked_args = {str(json.loads(m["content"]).get("inn", "")) for m in checked}
|
||||
rx = [r for r in rx if not any(r["drug"].lower().startswith(c[:-1]) for c in checked_args if c)]
|
||||
if rx:
|
||||
return AssistantTurn(
|
||||
tool_calls=[ToolCall(id="d9", name="check_drug_for_patient", arguments={"drug": rx[0]["drug"]})]
|
||||
)
|
||||
return AssistantTurn(content=_compose(done))
|
||||
|
||||
|
||||
def _tool_json(done: list[dict[str, Any]], name: str) -> dict[str, Any] | None:
|
||||
for m in done:
|
||||
if m.get("name") == name:
|
||||
try:
|
||||
return json.loads(m["content"])
|
||||
except json.JSONDecodeError:
|
||||
return None
|
||||
return None
|
||||
|
||||
|
||||
def _compose(done: list[dict[str, Any]]) -> str:
|
||||
parts: list[str] = []
|
||||
seen: set[str] = set()
|
||||
for m in done:
|
||||
if m.get("name") != "check_drug_for_patient":
|
||||
continue
|
||||
data = json.loads(m["content"])
|
||||
if not data.get("found") or data["inn"] in seen:
|
||||
continue
|
||||
seen.add(data["inn"])
|
||||
findings = data.get("findings") or []
|
||||
if findings:
|
||||
parts.append(f"По вашей карте и инструкции к препарату «{data['inn']}» есть важное:")
|
||||
parts += [f"• {f['text']}" for f in findings[:3]]
|
||||
else:
|
||||
parts.append(f"В справочнике не нашлось особых ограничений по «{data['inn']}» с учётом вашей карты.")
|
||||
for m in done:
|
||||
if m.get("name") != "get_drug_info":
|
||||
continue
|
||||
data = json.loads(m["content"])
|
||||
comp = data.get("composition") if data.get("found") else None
|
||||
if comp:
|
||||
record = _tool_json(done, "get_patient_record") or {}
|
||||
allergies = record.get("allergies") or []
|
||||
if allergies:
|
||||
names = ", ".join(a["name"] for a in allergies)
|
||||
hit = {t for a in allergies for t in a.get("tags", [])} & set(comp.get("excipient_tags", []))
|
||||
verdict = "это вещество есть" if hit else "этого вещества нет, но состав зависит от производителя"
|
||||
parts.append(f"В вашей карте: {names}. В примере состава «{data['inn']}» {verdict}.")
|
||||
excipients = ", ".join(comp["excipients"])
|
||||
parts.append(f"Состав ({comp['form']}): {comp['active']}; вспомогательные: {excipients}. {comp['note']}")
|
||||
search = _tool_json(done, "search_guidelines") or {}
|
||||
results = search.get("results") or []
|
||||
if results and not parts: # medicine findings already answer the question; a KR quote would dilute it
|
||||
text = results[0]["text"].strip()
|
||||
parts.append(f"В клинических рекомендациях: «{text[:400]}{'…' if len(text) > 400 else ''}»")
|
||||
if not parts:
|
||||
return ""
|
||||
parts.append("Любые изменения в лечении обсуждайте с вашим врачом.")
|
||||
return "\n".join(parts)
|
||||
@@ -0,0 +1,200 @@
|
||||
"""Read-only tools of the chat agent. Every tool is bound to the current patient's token on the server side:
|
||||
the model never passes a token, so it cannot read another patient's data (medical secrecy, 323-FZ art. 13).
|
||||
|
||||
Tool results contain clinical data only (no name, SNILS, phone) — they are sent to the LLM provider.
|
||||
"""
|
||||
|
||||
import json
|
||||
import logging
|
||||
import re
|
||||
from dataclasses import dataclass, field
|
||||
from typing import Any
|
||||
|
||||
from app.integrations.emias_record import PatientRecord, emias_records
|
||||
from app.llm.agent.drug_safety import check_patient, find_drug, load_db
|
||||
from app.llm.rag import retrieve
|
||||
from app.llm.rag.index import sentences
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
RAG_TOP_K = 4
|
||||
PASSAGE_CHARS = 700
|
||||
# Patients never get dosages (SPEC §7): sentences with doses are dropped before the text reaches the LLM.
|
||||
_DOSE = re.compile(r"\d\s*(?:-|–)?\s*\d*\s*(?:мг|mg|мкг|г/сут|таблетк)|\bдоз(?:а|у|ы|е|ой|ировк)", re.I)
|
||||
|
||||
TOOL_SPECS: list[dict[str, Any]] = [
|
||||
{
|
||||
"type": "function",
|
||||
"function": {
|
||||
"name": "search_guidelines",
|
||||
"description": (
|
||||
"Поиск по базе знаний: клинические рекомендации Минздрава РФ (депрессия 2024, ПТСР 2023). "
|
||||
"Возвращает фрагменты с источником и страницей. Используй для любых общих вопросов о состоянии, "
|
||||
"лечении, сроках действия терапии, побочных эффектах, отмене, образе жизни."
|
||||
),
|
||||
"parameters": {
|
||||
"type": "object",
|
||||
"properties": {"query": {"type": "string", "description": "Поисковый запрос на русском"}},
|
||||
"required": ["query"],
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
"type": "function",
|
||||
"function": {
|
||||
"name": "get_patient_record",
|
||||
"description": (
|
||||
"Медицинская карта текущего пациента из ЕМИАС: диагнозы (МКБ-10), сопутствующие заболевания, "
|
||||
"аллергии и непереносимости, назначения других врачей и текущее назначение психиатра. "
|
||||
"Вызывай, когда ответ зависит от особенностей пациента или его лекарств."
|
||||
),
|
||||
"parameters": {"type": "object", "properties": {}},
|
||||
},
|
||||
},
|
||||
{
|
||||
"type": "function",
|
||||
"function": {
|
||||
"name": "get_drug_info",
|
||||
"description": (
|
||||
"Справка о препарате по инструкции ГРЛС: состав (действующее и вспомогательные вещества), "
|
||||
"противопоказания, взаимодействия, беременность. Аргумент — название препарата (МНН или торговое)."
|
||||
),
|
||||
"parameters": {
|
||||
"type": "object",
|
||||
"properties": {"drug": {"type": "string"}},
|
||||
"required": ["drug"],
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
"type": "function",
|
||||
"function": {
|
||||
"name": "check_drug_for_patient",
|
||||
"description": (
|
||||
"Детерминированная проверка препарата для текущего пациента: сопутствующие заболевания, "
|
||||
"непереносимости по составу, взаимодействия с другими его лекарствами. Используй перед любым "
|
||||
"ответом о том, подходит ли пациенту препарат или сочетание препаратов."
|
||||
),
|
||||
"parameters": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"drug": {"type": "string", "description": "Название препарата; пусто — текущее назначение пациента"}
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
]
|
||||
|
||||
|
||||
@dataclass
|
||||
class ToolContext:
|
||||
token: str
|
||||
sources: list[str] = field(default_factory=list) # citations collected for the answer footer
|
||||
used: list[str] = field(default_factory=list)
|
||||
_record: PatientRecord | None = None
|
||||
_record_loaded: bool = False
|
||||
|
||||
async def record(self) -> PatientRecord | None:
|
||||
if not self._record_loaded:
|
||||
self._record = await emias_records.get(self.token)
|
||||
self._record_loaded = True
|
||||
return self._record
|
||||
|
||||
def cite(self, label: str) -> None:
|
||||
if label and label not in self.sources:
|
||||
self.sources.append(label)
|
||||
|
||||
|
||||
async def run_tool(ctx: ToolContext, name: str, args: dict[str, Any]) -> str:
|
||||
"""Execute a tool; always returns a JSON string (errors included) so the model can recover."""
|
||||
ctx.used.append(name)
|
||||
log.info("agent tool=%s", name) # no arguments: they may echo patient text
|
||||
try:
|
||||
if name == "search_guidelines":
|
||||
return _json(_search(ctx, str(args.get("query", ""))))
|
||||
if name == "get_patient_record":
|
||||
rec = await ctx.record()
|
||||
if rec is None:
|
||||
return _json({"found": False})
|
||||
ctx.cite("ЕМИАС: медицинская карта")
|
||||
return _json({"found": True, **rec.model_dump()})
|
||||
if name == "get_drug_info":
|
||||
return _json(_drug_info(ctx, str(args.get("drug", ""))))
|
||||
if name == "check_drug_for_patient":
|
||||
return _json(await _check(ctx, str(args.get("drug", ""))))
|
||||
return _json({"error": f"unknown tool {name}"})
|
||||
except Exception as exc: # noqa: BLE001 — a tool failure must not crash the chat
|
||||
log.error("agent tool=%s failed: %s", name, type(exc).__name__)
|
||||
return _json({"error": "tool failed"})
|
||||
|
||||
|
||||
def _search(ctx: ToolContext, query: str) -> dict[str, Any]:
|
||||
hits = retrieve(query, audience="patient", top_k=RAG_TOP_K) if query.strip() else []
|
||||
out = []
|
||||
for h in hits:
|
||||
label = h.chunk.citation.strip("[]")
|
||||
ctx.cite(label)
|
||||
text = " ".join(x for x in sentences(h.passage) if not _DOSE.search(x))[:PASSAGE_CHARS]
|
||||
if text:
|
||||
out.append({"source": label, "section": h.chunk.section, "text": text})
|
||||
return {"results": out, "found": bool(out)}
|
||||
|
||||
|
||||
def _drug_info(ctx: ToolContext, name: str) -> dict[str, Any]:
|
||||
entry = find_drug(name)
|
||||
if entry is None:
|
||||
return {"found": False, "drug": name}
|
||||
ctx.cite(entry.source)
|
||||
return {
|
||||
"found": True,
|
||||
"inn": entry.inn,
|
||||
"class": entry.drug_class,
|
||||
"composition": entry.composition.model_dump() if entry.composition else None,
|
||||
"contraindications": entry.contraindications,
|
||||
"interactions": [i.text for i in entry.interactions],
|
||||
"pregnancy": entry.pregnancy,
|
||||
"source": entry.source,
|
||||
}
|
||||
|
||||
|
||||
async def _check(ctx: ToolContext, name: str) -> dict[str, Any]:
|
||||
entry = find_drug(name) if name.strip() else None
|
||||
if entry is None:
|
||||
# "мои таблетки" / no name → the current psychiatric prescription from the record.
|
||||
rec = await ctx.record()
|
||||
current = [find_drug(p.drug) for p in (rec.current_prescriptions if rec else [])]
|
||||
entry = next((e for e in current if e is not None), None) if not find_drug(name) else None
|
||||
if entry is None:
|
||||
return {"found": False, "drug": name, "note": "Препарата нет в справочнике — отвечать «уточните у врача»."}
|
||||
rec = await ctx.record()
|
||||
if rec is None:
|
||||
return {"found": True, "inn": entry.inn, "record": False, "findings": []}
|
||||
ctx.cite(entry.source)
|
||||
ctx.cite("ЕМИАС: медицинская карта")
|
||||
db = load_db()
|
||||
findings = check_patient(entry, rec, db)
|
||||
comp = entry.composition
|
||||
intolerances = [a.name for a in rec.allergies]
|
||||
intolerance_check = None
|
||||
if comp is not None and intolerances:
|
||||
hit = {t for a in rec.allergies for t in a.tags} & set(comp.excipient_tags)
|
||||
intolerance_check = f"Непереносимость из карты ({', '.join(intolerances)}): " + (
|
||||
"вещество ЕСТЬ в составе."
|
||||
if hit
|
||||
else "в примере состава этого вещества нет; состав зависит от производителя."
|
||||
)
|
||||
return {
|
||||
"found": True,
|
||||
"inn": entry.inn,
|
||||
"record": True,
|
||||
"findings": [f.model_dump() for f in findings],
|
||||
"intolerance_check": intolerance_check,
|
||||
"composition": comp.model_dump(exclude={"excipient_tags"}) if comp else None,
|
||||
"general_interactions": [i.text for i in entry.interactions], # incl. alcohol — for questions about it
|
||||
"contraindications": entry.contraindications,
|
||||
"note": "Пустой findings не означает, что препарат безопасен: решение о приёме принимает врач.",
|
||||
}
|
||||
|
||||
|
||||
def _json(data: Any) -> str:
|
||||
return json.dumps(data, ensure_ascii=False)
|
||||
+61
-8
@@ -9,7 +9,8 @@ The txt files come from `docs/source/rag/pdf_to_txt.py`: paragraphs are separate
|
||||
* "Комментарии: ..." after a recommendation stays with the recommendation (the comment explains it);
|
||||
* a line starting in lowercase continues the previous paragraph (cut by a page break the converter missed);
|
||||
* tables are split by rows, every table piece repeats the table header, so a chunk is readable alone;
|
||||
* each chunk keeps the page range it came from, for the citation "[КР ПТСР 2023, стр. 45]".
|
||||
* each chunk keeps the page range it came from, for the citation "[КР ПТСР 2023, стр. 45]"; inline
|
||||
"⟦стр. N⟧" markers (paragraph glued across a page break) are removed from the text but move the range.
|
||||
"""
|
||||
|
||||
import re
|
||||
@@ -25,6 +26,8 @@ from app.config import get_settings
|
||||
Audience = str # "doctor" | "patient" | "team"
|
||||
|
||||
PAGE_MARKER = re.compile(r"^--- стр\. (\d+) ---$")
|
||||
# A paragraph that flows onto the next page is glued by the converter; "⟦стр. N⟧" marks where page N begins.
|
||||
INLINE_PAGE = re.compile(r"\s*⟦стр\. (\d+)⟧\s*")
|
||||
TABLE_DIVIDER = re.compile(r"^\|(-+\|)+$")
|
||||
# "2.1 Жалобы и анамнез", "3.1.2. Купирующая терапия ..." — a numbered subsection title.
|
||||
SUBSECTION = re.compile(r"^(\d{1,2}(?:\.\d{1,2})+)\.?\s+([А-ЯЁA-Z].*)$") # not dates "28.07.2022 N ..."
|
||||
@@ -77,6 +80,9 @@ class RetrievalConfig(BaseModel):
|
||||
window_weight: float = 0.5
|
||||
# section title prefix -> score multiplier, per audience ({"patient": {"Приложение В": 1.5}})
|
||||
section_boost: dict[str, dict[str, float]] = Field(default_factory=dict)
|
||||
# doc id -> regexes naming its disease; a question naming one disease favours that document
|
||||
doc_cues: dict[str, list[str]] = Field(default_factory=dict)
|
||||
doc_cue_boost: float = 1.0
|
||||
|
||||
|
||||
class AnswerConfig(BaseModel):
|
||||
@@ -120,8 +126,46 @@ class _Unit:
|
||||
"""Indivisible piece of a chunk: a paragraph (with its comment) or one table row."""
|
||||
|
||||
text: str
|
||||
page: int
|
||||
page: int # page where the unit starts
|
||||
table_header: str | None = None # "| a | b |\n|---|---|" for table rows
|
||||
breaks: list[tuple[int, int]] = field(default_factory=list) # (offset in text, page starting there)
|
||||
|
||||
@property
|
||||
def page_end(self) -> int:
|
||||
return self.breaks[-1][1] if self.breaks else self.page
|
||||
|
||||
def page_at(self, offset: int) -> int:
|
||||
page = self.page
|
||||
for start, p in self.breaks:
|
||||
if start <= offset:
|
||||
page = p
|
||||
return page
|
||||
|
||||
def append(self, line: str, page: int, sep: str) -> None:
|
||||
"""Glue a continuation line; record a page break if it comes from a later page."""
|
||||
base = len(self.text) + len(sep)
|
||||
text, breaks = _strip_inline_pages(line)
|
||||
if page > self.page_end:
|
||||
self.breaks.append((base, page))
|
||||
self.breaks.extend((base + off, p) for off, p in breaks)
|
||||
self.text += sep + text
|
||||
|
||||
|
||||
def _strip_inline_pages(line: str) -> tuple[str, list[tuple[int, int]]]:
|
||||
"""Text without "⟦стр. N⟧" markers + (offset, page) of each marker in the cleaned text."""
|
||||
out, breaks, pos = [], [], 0
|
||||
for m in INLINE_PAGE.finditer(line):
|
||||
out.append(line[pos : m.start()])
|
||||
breaks.append((sum(len(x) for x in out) + 1, int(m.group(1))))
|
||||
out.append(" ")
|
||||
pos = m.end()
|
||||
out.append(line[pos:])
|
||||
return "".join(out), breaks
|
||||
|
||||
|
||||
def _new_unit(line: str, page: int) -> _Unit:
|
||||
text, breaks = _strip_inline_pages(line)
|
||||
return _Unit(text, page, breaks=breaks)
|
||||
|
||||
|
||||
@dataclass
|
||||
@@ -185,7 +229,7 @@ def _sections(text: str, skip: list[str]) -> list[_Section]:
|
||||
continue
|
||||
if first.startswith("[Изображение"):
|
||||
if not skipping: # transcribed figure: one unit, keeps its own line breaks
|
||||
sections[-1].units.append(_Unit("\n".join(block[1:]) if len(block) > 1 else first, page))
|
||||
sections[-1].units.append(_new_unit("\n".join(block[1:]) if len(block) > 1 else first, page))
|
||||
continue
|
||||
for j, line in enumerate(block):
|
||||
title = heading(line)
|
||||
@@ -199,11 +243,11 @@ def _sections(text: str, skip: list[str]) -> list[_Section]:
|
||||
continue
|
||||
units = sections[-1].units
|
||||
if COMMENT.match(line) and units and units[-1].table_header is None:
|
||||
units[-1].text += "\n" + line
|
||||
units[-1].append(line, page, "\n")
|
||||
elif line[0].islower() and units and units[-1].table_header is None:
|
||||
units[-1].text += " " + line # paragraph continued after a page break or a figure
|
||||
units[-1].append(line, page, " ") # paragraph continued after a page break or a figure
|
||||
else:
|
||||
units.append(_Unit(line, page))
|
||||
units.append(_new_unit(line, page))
|
||||
return [s for s in sections if s.units]
|
||||
|
||||
|
||||
@@ -236,7 +280,16 @@ def _split_long(unit: _Unit, max_chars: int) -> list[_Unit]:
|
||||
parts[-1] += " " + sentence
|
||||
else:
|
||||
parts.append(sentence)
|
||||
return [_Unit(p, unit.page) for p in parts]
|
||||
out: list[_Unit] = []
|
||||
pos = 0
|
||||
for part in parts:
|
||||
start = unit.text.find(part[:40], pos)
|
||||
start = pos if start < 0 else start
|
||||
end = start + len(part) - 1
|
||||
first, last = unit.page_at(start), unit.page_at(end)
|
||||
out.append(_Unit(part, first, breaks=[(len(part) - 1, last)] if last != first else []))
|
||||
pos = start + len(part)
|
||||
return out
|
||||
|
||||
|
||||
def _render(units: list[_Unit]) -> str:
|
||||
@@ -280,7 +333,7 @@ def chunk_document(doc: DocumentMeta, text: str, cfg: ChunkingConfig) -> list[Ch
|
||||
doc=doc,
|
||||
section=section.title,
|
||||
page_start=group[0].page,
|
||||
page_end=group[-1].page,
|
||||
page_end=max(u.page_end for u in group),
|
||||
text=_render(group),
|
||||
)
|
||||
)
|
||||
|
||||
+22
-5
@@ -20,6 +20,8 @@ from app.llm.rag.corpus import Audience, Chunk, RagConfig, load_chunks, load_con
|
||||
from app.llm.rag.stemmer import stem
|
||||
|
||||
_WORD = re.compile(r"[а-яёa-z0-9]+(?:-[а-яёa-z0-9]+)*", re.IGNORECASE)
|
||||
# `privacy.scrub()` placeholders ("[NAME]", "[PHONE]") are not words of the question.
|
||||
_PLACEHOLDER = re.compile(r"\[[A-Z_]+\]")
|
||||
|
||||
# Function words and generic KR boilerplate that carry no topical signal.
|
||||
STOP_WORDS = frozenset(
|
||||
@@ -36,7 +38,7 @@ STOP_WORDS = frozenset(
|
||||
def tokens(text: str) -> list[str]:
|
||||
"""Stems of content words (hyphenated words are kept whole and also split: "когнитивно-поведенческая")."""
|
||||
out: list[str] = []
|
||||
for word in _WORD.findall(text.lower().replace("ё", "е")):
|
||||
for word in _WORD.findall(_PLACEHOLDER.sub(" ", text).lower().replace("ё", "е")):
|
||||
parts = [p for p in word.split("-") if p not in STOP_WORDS and (len(p) > 1 or p.isdigit())]
|
||||
if "-" in word and len(parts) > 1:
|
||||
out.append("-".join(stem(p) for p in parts)) # the compound itself, in any case form
|
||||
@@ -97,6 +99,8 @@ class BM25Index:
|
||||
self._k1, self._b, self._min_score, self._top_k = r.bm25_k1, r.bm25_b, r.min_score, r.top_k
|
||||
self._candidates, self._window, self._window_weight = r.rerank_candidates, r.window_sentences, r.window_weight
|
||||
self._section_boost = r.section_boost
|
||||
self._doc_cues = {doc: re.compile("|".join(cues), re.IGNORECASE) for doc, cues in r.doc_cues.items() if cues}
|
||||
self._doc_cue_boost = r.doc_cue_boost
|
||||
self.chunks = chunks
|
||||
self._sentences = [[(s, set(tokens(s))) for s in sentences(c.text)] for c in chunks]
|
||||
self._expander = SynonymExpander(cfg.synonyms)
|
||||
@@ -124,10 +128,20 @@ class BM25Index:
|
||||
score += self._idf[term] * f * (self._k1 + 1) / (f + norm) * weight
|
||||
return score
|
||||
|
||||
def boost(self, chunk: Chunk, audience: Audience | None) -> float:
|
||||
"""Section multiplier for the audience (`retrieval.section_boost`), 1.0 by default."""
|
||||
def boost(self, chunk: Chunk, audience: Audience | None, cued: set[str] | None = None) -> float:
|
||||
"""Section multiplier for the audience (`retrieval.section_boost`) × disease-cue multiplier."""
|
||||
boosts = self._section_boost.get(audience or "", {})
|
||||
return next((b for prefix, b in boosts.items() if chunk.section.startswith(prefix)), 1.0)
|
||||
section = next((b for prefix, b in boosts.items() if chunk.section.startswith(prefix)), 1.0)
|
||||
return section * (self._doc_cue_boost if cued and chunk.doc.id in cued else 1.0)
|
||||
|
||||
def cued_docs(self, query: str) -> set[str]:
|
||||
"""Documents whose disease the query names ("ТМС при депрессии" -> {"kr_depression"}).
|
||||
|
||||
Only a one-sided mention counts: a question naming both disorders favours neither.
|
||||
"""
|
||||
q = _PLACEHOLDER.sub(" ", query).replace("ё", "е")
|
||||
cued = {doc for doc, cue in self._doc_cues.items() if cue.search(q)}
|
||||
return cued if len(cued) < len(self._doc_cues) else set()
|
||||
|
||||
def overlap(self, text: str, terms: dict[str, float]) -> float:
|
||||
"""Sum of idf × weight of the query terms present in `text` (sentence relevance for `answer()`)."""
|
||||
@@ -193,11 +207,14 @@ class BM25Index:
|
||||
and (s := self._score(i, terms)) >= threshold
|
||||
]
|
||||
scored.sort(key=lambda x: (-x[0], x[1]))
|
||||
cued = self.cued_docs(query)
|
||||
hits = []
|
||||
for bm25, i in scored[: max(self._candidates, top_k or 0)]:
|
||||
bonus, passage = self._passage(i, terms)
|
||||
chunk = self.chunks[i]
|
||||
hits.append(Hit(chunk, (bm25 + self._window_weight * bonus) * self.boost(chunk, audience), bm25, passage))
|
||||
hits.append(
|
||||
Hit(chunk, (bm25 + self._window_weight * bonus) * self.boost(chunk, audience, cued), bm25, passage)
|
||||
)
|
||||
hits.sort(key=lambda h: -h.score) # stable: BM25 order breaks ties
|
||||
return hits[: top_k or self._top_k]
|
||||
|
||||
|
||||
+6
-3
@@ -56,6 +56,7 @@ PRESCRIBING = re.compile(
|
||||
)
|
||||
# "что такое флэшбек" -> the term; its definition "Флэшбек (flashback – англ.) – ..." is preferred.
|
||||
DEFINITION_QUESTION = re.compile(r"^\s*что (?:такое|значит|означает|это за)\s+(.+?)[?.!\s]*$", re.IGNORECASE)
|
||||
LEADING_PLACEHOLDERS = re.compile(r"^(?:\s*\[[A-Z_]+\][\s,.:;!-]*)+") # "[NAME], что такое ПТСР?"
|
||||
DEFINITION_HEAD = re.compile(r"\s[–—-]\s(?![^(]*\))|\s[–—-]?\s?это\s") # dash outside "(… – англ.)", or "это"
|
||||
DEFINITION_HEAD_CHARS = 60
|
||||
DEFINITION_BONUS = 2.0 # multiplier for a sentence that starts with the asked term (picks it within a chunk)
|
||||
@@ -174,7 +175,7 @@ def _allowed(sentence: str | None, audience: Audience) -> bool:
|
||||
|
||||
|
||||
def _defined_term(question: str) -> set[str] | None:
|
||||
m = DEFINITION_QUESTION.match(question)
|
||||
m = DEFINITION_QUESTION.match(LEADING_PLACEHOLDERS.sub("", question))
|
||||
return set(tokens(m.group(1))) or None if m else None
|
||||
|
||||
|
||||
@@ -198,6 +199,7 @@ def best_passage(
|
||||
audience: Audience,
|
||||
cfg: AnswerConfig,
|
||||
defined: set[str] | None = None,
|
||||
cued: set[str] | None = None,
|
||||
) -> Passage | None:
|
||||
"""Best sentence of the chunk extended by adjacent relevant sentences (contiguous, within limits)."""
|
||||
sents = [s if _allowed(s, audience) else None for s in chunk_sentences(chunk, clinical=audience != "patient")]
|
||||
@@ -235,7 +237,7 @@ def best_passage(
|
||||
size += length(nxt)
|
||||
text = " ".join(s for s in sents[lo : hi + 1] if s)
|
||||
definition = scores[best] > index.overlap(head, terms) # got DEFINITION_BONUS
|
||||
return Passage(chunk, text, index.overlap(text, terms) * index.boost(chunk, audience), definition)
|
||||
return Passage(chunk, text, index.overlap(text, terms) * index.boost(chunk, audience, cued), definition)
|
||||
|
||||
|
||||
def select(index: BM25Index, question: str, audience: Audience, docs: set[str] | None = None) -> list[Passage]:
|
||||
@@ -244,7 +246,8 @@ def select(index: BM25Index, question: str, audience: Audience, docs: set[str] |
|
||||
hits = index.search(question, audience=audience, docs=docs, top_k=cfg.max_chunks)
|
||||
terms = index.query_terms(question)
|
||||
defined = _defined_term(question)
|
||||
passages = [p for h in hits if (p := best_passage(index, h.chunk, terms, audience, cfg, defined))]
|
||||
cued = index.cued_docs(question)
|
||||
passages = [p for h in hits if (p := best_passage(index, h.chunk, terms, audience, cfg, defined, cued))]
|
||||
if not passages:
|
||||
return []
|
||||
# A definition answers "что такое X?" better than any passage that merely mentions X often.
|
||||
|
||||
Reference in New Issue
Block a user