hunjing/backend/app/services/serializers.py

"""ORM 到 API schema 的转换。"""

from datetime import UTC, timedelta
from typing import Any

from app.models.governance import GenerationPreferences
from app.core.time import to_iso, utc_now
from app.models.character import Character
from app.models.imports import CharacterImportJob, ImportItem
from app.models.runtime import Event, Run
from app.models.safety import AuditEvent
from app.repositories.json_utils import loads_dict, loads_list
from app.schemas.admin import AuditEntry
from app.schemas.character import CharacterResponse, CharacterSummaryResponse
from app.schemas.imports import ImportItemResponse, ImportJobResponse
from app.schemas.preferences import GenerationPreferencesResponse
from app.schemas.runtime import EventResponse, RunResponse



def character_to_response(character: Character) -> CharacterResponse:
    return CharacterResponse(
        id=character.id,
        name=character.name,
        display_name=character.display_name,
        status=character.status,
        language=character.language,
        profile=loads_dict(character.profile_json),
        model_policy=loads_dict(character.model_policy_json),
        privacy_level=character.privacy_level,
        owner_scope=character.owner_scope,
        is_system_template=character.is_system_template,
        source_template_id=character.source_template_id,
        created_at=to_iso(character.created_at) or "",
        updated_at=to_iso(character.updated_at) or "",
    )


def character_to_summary(
    character: Character, *, memory_count: int, personality_version: int
) -> CharacterSummaryResponse:
    """人物列表项（api-spec §6）；memory_count / personality_version 由调用方查得。"""
    return CharacterSummaryResponse(
        id=character.id,
        name=character.name,
        display_name=character.display_name,
        status=character.status,
        memory_count=memory_count,
        personality_version=personality_version,
        activated_at=to_iso(character.activated_at),
    )




def run_to_response(run: Run) -> RunResponse:
    return RunResponse(
        id=run.id,
        character_id=run.character_id,
        status=run.status,
        kind=run.kind,
        goal=run.goal,
        origin=run.origin,
        model_hint=run.model_hint,
        started_at=to_iso(run.started_at),
        completed_at=to_iso(run.completed_at),
        error_code=run.error_code,
        error_message=run.error_message,
        created_at=to_iso(run.created_at) or "",
        updated_at=to_iso(run.updated_at) or "",
    )


def event_to_response(event: Event) -> EventResponse:
    payload: dict[str, Any] = loads_dict(event.payload_json)
    return EventResponse(
        event_id=event.id,
        run_id=event.run_id,
        character_id=event.character_id,
        type=event.type,
        sequence=event.sequence,
        visibility=event.visibility,
        payload=payload,
        created_at=to_iso(event.created_at) or "",
        trace_id=event.trace_id,
    )


# —— 司命台治理对象 ——






def generation_preferences_to_response(
    prefs: GenerationPreferences,
) -> GenerationPreferencesResponse:
    return GenerationPreferencesResponse(
        default_model_hint=prefs.default_model_hint,
        temperature=prefs.temperature,
        top_p=prefs.top_p,
        max_output_tokens=prefs.max_output_tokens,
        streaming=prefs.streaming,
    )


def audit_to_response(event: AuditEvent) -> AuditEntry:
    summary = event.reason or event.input_summary or event.output_summary or event.action
    return AuditEntry(
        audit_id=event.id,
        pivot=event.pivot or "memory",
        actor=event.actor,
        action=event.action,
        subject=event.resource_id,
        decision=event.decision,
        risk_level=event.risk_level,
        summary=summary,
        trace_id=event.trace_id,
        created_at=to_iso(event.created_at),
    )


def import_job_to_response(job: CharacterImportJob) -> ImportJobResponse:
    return ImportJobResponse(
        id=job.id,
        character_id=job.character_id,
        material_type=job.material_type,
        source_type=job.source_type,
        title=job.title,
        status=job.status,
        format=job.format,
        media_type=job.media_type,
        mime_type=job.mime_type,
        item_count=job.item_count,
        consent_status=job.consent_status,
        usage_scope=job.usage_scope,
        error_code=job.error_code,
        error_message=job.error_message,
        created_at=to_iso(job.created_at) or "",
        updated_at=to_iso(job.updated_at) or "",
    )


def import_item_to_response(item: ImportItem) -> ImportItemResponse:
    return ImportItemResponse(
        id=item.id,
        import_job_id=item.import_job_id,
        item_type=item.item_type,
        role=item.role,
        sequence=item.sequence,
        content=item.content,
        metadata=loads_dict(item.metadata_json),
        created_at=to_iso(item.created_at) or "",
    )




def profile_candidate_to_response(candidate):  # noqa: ANN001 — 旧导入候选（M6 退役）
    from app.schemas.candidates import ProfileCandidateResponse

    return ProfileCandidateResponse.model_validate(candidate, from_attributes=True)