222 lines
7.9 KiB
Python
222 lines
7.9 KiB
Python
"""Browser-facing persona DTOs and deterministic mappers."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from typing import Any, Literal
|
|
|
|
from pydantic import BaseModel, Field
|
|
|
|
from .persona_repository import CatalogPersona, PersonaDraftRecord, PersonaReviewAction, PersonaReviewItem
|
|
from .services.persona import PersonaCard
|
|
|
|
JSON_OBJECT_FIELD = {"additionalProperties": True}
|
|
PersonaSourceKind = Literal["client_record", "textbook_guide", "mixed_notes"]
|
|
|
|
|
|
class PersonaSummary(BaseModel):
|
|
persona_id: str | None = None
|
|
code: str
|
|
version: int | None = None
|
|
status: Literal["approved"] = "approved"
|
|
display_name: str
|
|
difficulty: str
|
|
theory_target: list[str]
|
|
demographics: dict[str, Any]
|
|
presenting_summary: str
|
|
voice_preset: str | None = None
|
|
source: str = "database"
|
|
degraded: bool = False
|
|
|
|
|
|
class PersonaReviewSummary(BaseModel):
|
|
persona_id: str
|
|
code: str
|
|
version: int
|
|
status: Literal["draft", "review", "approved", "archived"]
|
|
display_name: str
|
|
difficulty: str
|
|
theory_target: list[str]
|
|
source_provenance: str
|
|
is_synthetic: bool
|
|
created_at: str | None = None
|
|
approved_at: str | None = None
|
|
|
|
|
|
class PersonaReviewDecisionRequest(BaseModel):
|
|
action: PersonaReviewAction
|
|
|
|
|
|
class PersonaRevisionRequest(BaseModel):
|
|
submit_for_review: bool = False
|
|
|
|
|
|
class PersonaDraftPayload(BaseModel):
|
|
code: str = Field(min_length=1, max_length=24)
|
|
display_name: str = Field(min_length=1, max_length=80)
|
|
difficulty: Literal["easy", "moderate", "hard"]
|
|
theory_target: list[str] = Field(default_factory=list)
|
|
demographics: dict[str, Any] = Field(default_factory=dict, json_schema_extra=JSON_OBJECT_FIELD)
|
|
presenting: dict[str, Any] = Field(default_factory=dict, json_schema_extra=JSON_OBJECT_FIELD)
|
|
history: dict[str, Any] = Field(default_factory=dict, json_schema_extra=JSON_OBJECT_FIELD)
|
|
big5: dict[str, float] = Field(default_factory=dict)
|
|
resistance: dict[str, float] = Field(default_factory=dict)
|
|
speech_style: dict[str, Any] = Field(default_factory=dict, json_schema_extra=JSON_OBJECT_FIELD)
|
|
affect_baseline: dict[str, float] = Field(default_factory=dict)
|
|
ccd: dict[str, Any] = Field(default_factory=dict, json_schema_extra=JSON_OBJECT_FIELD)
|
|
dsm5_dimensional: dict[str, Any] = Field(default_factory=dict, json_schema_extra=JSON_OBJECT_FIELD)
|
|
triggers: dict[str, Any] = Field(default_factory=dict, json_schema_extra=JSON_OBJECT_FIELD)
|
|
source_provenance: str = Field(default="", max_length=240)
|
|
is_synthetic: bool = True
|
|
submit_for_review: bool = False
|
|
|
|
|
|
class PersonaSourceDocumentRequest(BaseModel):
|
|
filename: str = Field(min_length=1, max_length=240)
|
|
source_kind: PersonaSourceKind = "mixed_notes"
|
|
text: str = Field(min_length=20, max_length=120000)
|
|
title: str | None = Field(default=None, max_length=160)
|
|
source_note: str = Field(default="", max_length=800)
|
|
|
|
|
|
class PersonaSourceDocumentResponse(BaseModel):
|
|
source_id: str
|
|
doc_id: int | None
|
|
doc_uri: str
|
|
title: str
|
|
source_kind: PersonaSourceKind
|
|
kb_kind: str
|
|
license_class: Literal["A", "B", "C", "D"] = "B"
|
|
external_llm_ok: bool = True
|
|
content_hash: str
|
|
chunk_count: int
|
|
chunks_indexed: int
|
|
embedded: bool
|
|
degraded: bool = False
|
|
pii_entities_masked: list[str] = Field(default_factory=list)
|
|
|
|
|
|
class PersonaGenerationEvidence(BaseModel):
|
|
chunk_id: int
|
|
source_id: str
|
|
score: float
|
|
kb_kind: str
|
|
heading_path: str | None = None
|
|
excerpt: str
|
|
|
|
|
|
class PersonaDraftGenerateRequest(BaseModel):
|
|
source_text: str | None = Field(default=None, min_length=20, max_length=30000)
|
|
source_ids: list[str] = Field(default_factory=list, max_length=12)
|
|
source_kind: PersonaSourceKind = "mixed_notes"
|
|
code_hint: str | None = Field(default=None, max_length=24)
|
|
display_name_hint: str | None = Field(default=None, max_length=80)
|
|
difficulty: Literal["easy", "moderate", "hard"] = "moderate"
|
|
theory_target: list[str] = Field(default_factory=lambda: ["humanistic"])
|
|
generation_goal: str = Field(default="", max_length=800)
|
|
|
|
|
|
class PersonaDraftGenerateResponse(BaseModel):
|
|
draft: PersonaDraftPayload
|
|
source_summary: str = ""
|
|
warnings: list[str] = Field(default_factory=list)
|
|
pii_entities_masked: list[str] = Field(default_factory=list)
|
|
source_references: list[PersonaSourceDocumentResponse] = Field(default_factory=list)
|
|
evidence_chunks: list[PersonaGenerationEvidence] = Field(default_factory=list)
|
|
|
|
|
|
class PersonaDraftDetail(PersonaReviewSummary):
|
|
demographics: dict[str, Any] = Field(json_schema_extra=JSON_OBJECT_FIELD)
|
|
presenting: dict[str, Any] = Field(json_schema_extra=JSON_OBJECT_FIELD)
|
|
history: dict[str, Any] = Field(json_schema_extra=JSON_OBJECT_FIELD)
|
|
big5: dict[str, float]
|
|
resistance: dict[str, float]
|
|
speech_style: dict[str, Any] = Field(json_schema_extra=JSON_OBJECT_FIELD)
|
|
affect_baseline: dict[str, float]
|
|
ccd: dict[str, Any] = Field(json_schema_extra=JSON_OBJECT_FIELD)
|
|
dsm5_dimensional: dict[str, Any] = Field(json_schema_extra=JSON_OBJECT_FIELD)
|
|
triggers: dict[str, Any] = Field(json_schema_extra=JSON_OBJECT_FIELD)
|
|
|
|
|
|
def _first_text_value(data: dict[str, Any]) -> str:
|
|
for value in data.values():
|
|
if isinstance(value, str) and value.strip():
|
|
return value.strip()
|
|
return ""
|
|
|
|
|
|
def persona_summary(entry: CatalogPersona) -> PersonaSummary:
|
|
card = entry.card
|
|
return PersonaSummary(
|
|
persona_id=entry.persona_id,
|
|
code=card.code,
|
|
version=entry.version,
|
|
status="approved",
|
|
display_name=card.display_name,
|
|
difficulty=card.difficulty,
|
|
theory_target=card.theory_target,
|
|
demographics=card.demographics,
|
|
presenting_summary=_first_text_value(card.presenting),
|
|
source=entry.source,
|
|
degraded=entry.degraded,
|
|
)
|
|
|
|
|
|
def persona_review_summary(entry: PersonaReviewItem) -> PersonaReviewSummary:
|
|
return PersonaReviewSummary(
|
|
persona_id=entry.persona_id,
|
|
code=entry.code,
|
|
version=entry.version,
|
|
status=entry.status,
|
|
display_name=entry.display_name,
|
|
difficulty=entry.difficulty,
|
|
theory_target=entry.theory_target,
|
|
source_provenance=entry.source_provenance,
|
|
is_synthetic=entry.is_synthetic,
|
|
created_at=entry.created_at,
|
|
approved_at=entry.approved_at,
|
|
)
|
|
|
|
|
|
def persona_draft_detail(entry: PersonaDraftRecord) -> PersonaDraftDetail:
|
|
card = entry.card
|
|
return PersonaDraftDetail(
|
|
**persona_review_summary(entry.review).model_dump(),
|
|
demographics=card.demographics,
|
|
presenting=card.presenting,
|
|
history=card.history,
|
|
big5=card.big5,
|
|
resistance=card.resistance,
|
|
speech_style=card.speech_style,
|
|
affect_baseline=card.affect_baseline,
|
|
ccd=card.ccd,
|
|
dsm5_dimensional=card.dsm5_dimensional,
|
|
triggers=card.triggers,
|
|
)
|
|
|
|
|
|
def persona_card_from_draft_payload(request: PersonaDraftPayload) -> PersonaCard:
|
|
code = request.code.strip().upper()
|
|
display_name = request.display_name.strip()
|
|
if not code:
|
|
raise ValueError("persona code is required")
|
|
if not display_name:
|
|
raise ValueError("display_name is required")
|
|
theory_target = [value.strip().lower() for value in request.theory_target if value.strip()]
|
|
return PersonaCard(
|
|
code=code,
|
|
display_name=display_name,
|
|
difficulty=request.difficulty,
|
|
theory_target=theory_target,
|
|
demographics=request.demographics,
|
|
presenting=request.presenting,
|
|
history=request.history,
|
|
big5=request.big5,
|
|
resistance=request.resistance,
|
|
speech_style=request.speech_style,
|
|
affect_baseline=request.affect_baseline,
|
|
ccd=request.ccd,
|
|
dsm5_dimensional=request.dsm5_dimensional,
|
|
triggers=request.triggers,
|
|
source_provenance=request.source_provenance.strip(),
|
|
is_synthetic=request.is_synthetic,
|
|
)
|