Tricoder/backend/app/services/analysis_service.py

from uuid import uuid4

from fastapi import HTTPException, status

from app.repositories.analysis_repository import AnalysisRepository
from app.repositories.observation_repository import ObservationRepository
from app.schemas.analysis import (
    AnalysisSessionCreateRequest,
    AnalysisSessionListResponse,
    AnalysisSessionResponse,
    AnalysisSessionSnapshot,
)
from app.schemas.observation import ObservationSummary
from app.schemas.orchestration import OrchestratorPlan
from app.services.stub_orchestrator_service import StubOrchestratorService
from app.services.stub_runner_service import StubRunnerService


class AnalysisService:
    def __init__(self) -> None:
        self.repository = AnalysisRepository()
        self.observation_repository = ObservationRepository()
        self.orchestrator = StubOrchestratorService()
        self.runner = StubRunnerService()

    def create_session(
        self,
        payload: AnalysisSessionCreateRequest,
    ) -> AnalysisSessionResponse:
        session_id = str(uuid4())
        observation = self.observation_repository.get(payload.observation_id)
        if observation is None:
            raise HTTPException(
                status_code=status.HTTP_404_NOT_FOUND,
                detail=f"Observation '{payload.observation_id}' was not found.",
            )
        plan = self.orchestrator.create_initial_plan(observation)
        snapshot = self._build_stub_snapshot(
            session_id=session_id,
            observation=observation,
            mode=payload.mode,
            plan=plan,
        )
        self.repository.save_snapshot(snapshot)

        return AnalysisSessionResponse(
            session_id=session_id,
            observation_id=payload.observation_id,
            status=snapshot.status,
            message="Analysis session created and seeded with stub experiment data.",
        )

    def get_session(self, session_id: str) -> AnalysisSessionSnapshot | None:
        return self.repository.get_snapshot(session_id)

    def list_sessions(self) -> AnalysisSessionListResponse:
        return self.repository.list_sessions()

    def _build_stub_snapshot(
        self,
        *,
        session_id: str,
        observation: ObservationSummary,
        mode: str,
        plan: OrchestratorPlan,
    ) -> AnalysisSessionSnapshot:
        run = self.runner.run_initial_plan(
            session_id=session_id,
            observation=observation,
            plan=plan,
        )

        return AnalysisSessionSnapshot(
            session_id=session_id,
            observation_id=observation.id,
            status=run.status,
            mode=mode,
            observation=observation,
            hypotheses=plan.hypotheses,
            probe_evidence=run.probe_evidence,
            experiments=run.experiments,
            conclusion=run.conclusion,
        )