228 lines
8.4 KiB
Python
228 lines
8.4 KiB
Python
"""Define API routes for compliance."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
import json
|
|
from pathlib import Path
|
|
from typing import AsyncGenerator, Optional
|
|
|
|
from fastapi import APIRouter, Depends, File, Form, UploadFile
|
|
from fastapi.responses import StreamingResponse
|
|
from loguru import logger
|
|
|
|
from app.api.dependencies.auth import get_current_user
|
|
from app.domain.auth.models import UserClaims
|
|
from app.schemas.compliance import (
|
|
AnalyzeResponse,
|
|
ComplianceChatRequest,
|
|
)
|
|
from app.services.mock_data import generate_task_id, get_mock_compliance_result
|
|
from app.shared.bootstrap import get_agent_conversation_service, get_retrieval_service
|
|
from app.config.settings import settings
|
|
|
|
|
|
router = APIRouter(prefix="/compliance", tags=["合规分析"])
|
|
|
|
tasks_store: dict[str, dict] = {}
|
|
|
|
RAW_DATA_DIR = Path(__file__).resolve().parents[3] / "data" / "raw"
|
|
|
|
|
|
@router.post("/analyze", response_model=AnalyzeResponse)
|
|
async def analyze_document(file: UploadFile = File(...)):
|
|
"""Handle analyze document."""
|
|
task_id = generate_task_id()
|
|
|
|
RAW_DATA_DIR.mkdir(parents=True, exist_ok=True)
|
|
file_path = RAW_DATA_DIR / f"compliance_{task_id}_{file.filename}"
|
|
|
|
content = await file.read()
|
|
with file_path.open("wb") as f:
|
|
f.write(content)
|
|
|
|
tasks_store[task_id] = {
|
|
"task_id": task_id,
|
|
"file_path": str(file_path),
|
|
"status": "processing",
|
|
"result": None,
|
|
}
|
|
|
|
tasks_store[task_id]["status"] = "completed"
|
|
tasks_store[task_id]["result"] = get_mock_compliance_result(task_id)
|
|
|
|
return AnalyzeResponse(task_id=task_id)
|
|
|
|
|
|
@router.get("/result/{task_id}")
|
|
async def get_result(task_id: str):
|
|
"""Return result."""
|
|
if task_id not in tasks_store:
|
|
return get_mock_compliance_result(task_id)
|
|
|
|
task = tasks_store[task_id]
|
|
if task["status"] == "processing":
|
|
return {"status": "processing", "message": "分析进行中"}
|
|
return task["result"]
|
|
|
|
|
|
def _sse(data: dict) -> str:
|
|
return f"event: message\ndata: {json.dumps(data, ensure_ascii=False)}\n\n"
|
|
|
|
|
|
@router.post("/analyze-stream")
|
|
async def analyze_stream(
|
|
text: Optional[str] = Form(None),
|
|
doc_id: Optional[str] = Form(None),
|
|
file: Optional[UploadFile] = File(None),
|
|
domains: Optional[str] = Form(None),
|
|
title: Optional[str] = Form(None),
|
|
current_user: UserClaims = Depends(get_current_user),
|
|
):
|
|
"""Stream compliance analysis as SSE events.
|
|
|
|
Stages: clause_split → retrieval (per clause) → gap_check → conclusion
|
|
Events: stage | source | finding | done | error
|
|
"""
|
|
from app.application.compliance.pipeline import (
|
|
check_clause_compliance,
|
|
extract_text_from_doc_id,
|
|
extract_text_from_file,
|
|
retrieve_for_clause,
|
|
split_into_clauses,
|
|
synthesize_conclusion,
|
|
)
|
|
from app.services.llm.llm_factory import get_llm_client
|
|
from app.shared.bootstrap import get_retrieval_service
|
|
|
|
# Read file content eagerly (before async generator)
|
|
file_content: bytes | None = None
|
|
file_name: str | None = None
|
|
if file is not None:
|
|
file_content = await file.read()
|
|
file_name = file.filename
|
|
|
|
async def generate() -> AsyncGenerator[str, None]:
|
|
try:
|
|
client = get_llm_client(provider=settings.llm_provider, model=settings.llm_model)
|
|
retrieval_service = get_retrieval_service()
|
|
|
|
# ── Stage 1: extract text ─────────────────────────────────────
|
|
yield _sse({"type": "stage", "stage": "extracting", "label": "Extracting text…"})
|
|
await asyncio.sleep(0)
|
|
|
|
if text:
|
|
para_text = text.strip()
|
|
elif doc_id:
|
|
try:
|
|
para_text = await asyncio.to_thread(extract_text_from_doc_id, doc_id)
|
|
except Exception as exc:
|
|
yield _sse({"type": "error", "text": f"Document not found: {exc}"})
|
|
return
|
|
elif file_content is not None:
|
|
para_text = await asyncio.to_thread(
|
|
extract_text_from_file, file_content, file_name or "upload"
|
|
)
|
|
else:
|
|
yield _sse({"type": "error", "text": "No input provided"})
|
|
return
|
|
|
|
if not para_text.strip():
|
|
yield _sse({"type": "error", "text": "Could not extract text from the provided input"})
|
|
return
|
|
|
|
# ── Stage 2: split into clauses ───────────────────────────────
|
|
yield _sse({"type": "stage", "stage": "splitting", "label": "Splitting into clauses…"})
|
|
await asyncio.sleep(0)
|
|
clauses: list[str] = await asyncio.to_thread(split_into_clauses, para_text, client)
|
|
|
|
# ── Stage 3: retrieve + gap check per clause ──────────────────
|
|
findings: list[dict] = []
|
|
|
|
for i, clause in enumerate(clauses):
|
|
yield _sse({
|
|
"type": "stage",
|
|
"stage": "analyzing",
|
|
"label": f"Analyzing clause {i + 1}/{len(clauses)}…",
|
|
})
|
|
await asyncio.sleep(0)
|
|
|
|
chunks = await asyncio.to_thread(
|
|
retrieve_for_clause, clause, retrieval_service, 5, domains or None
|
|
)
|
|
|
|
# Emit source events
|
|
for chunk in chunks[:3]:
|
|
yield _sse({
|
|
"type": "source",
|
|
"standard": getattr(chunk, "doc_title", "") or getattr(chunk, "doc_name", ""),
|
|
"clause": getattr(chunk, "section_title", "") or "",
|
|
"score": round(float(getattr(chunk, "score", 0)), 3),
|
|
"status": "retrieved",
|
|
"full_content": (getattr(chunk, "text", "") or "")[:300],
|
|
})
|
|
await asyncio.sleep(0)
|
|
|
|
finding = await asyncio.to_thread(check_clause_compliance, clause, chunks, client)
|
|
if finding:
|
|
findings.append(finding)
|
|
yield _sse({"type": "finding", **finding})
|
|
await asyncio.sleep(0)
|
|
|
|
# ── Stage 4: synthesize conclusion ────────────────────────────
|
|
yield _sse({"type": "stage", "stage": "concluding", "label": "Generating conclusion…"})
|
|
await asyncio.sleep(0)
|
|
|
|
conclusion_data = await asyncio.to_thread(
|
|
synthesize_conclusion, para_text, findings, client
|
|
)
|
|
yield _sse({"type": "done", **conclusion_data})
|
|
|
|
except Exception as exc:
|
|
logger.exception("analyze-stream pipeline error")
|
|
yield _sse({"type": "error", "text": str(exc)})
|
|
|
|
return StreamingResponse(
|
|
generate(),
|
|
media_type="text/event-stream",
|
|
headers={"Cache-Control": "no-cache", "Connection": "keep-alive", "X-Accel-Buffering": "no"},
|
|
)
|
|
|
|
|
|
@router.post("/chat/{segment_id}")
|
|
async def compliance_chat(segment_id: int, request: ComplianceChatRequest):
|
|
"""Stream compliance Q&A grounded in real vector retrieval."""
|
|
query = request.query
|
|
if request.segment_context:
|
|
query = f"[段落分析上下文]\n{request.segment_context}\n\n用户问题：{request.query}"
|
|
|
|
_, event_stream = get_agent_conversation_service().stream_chat(
|
|
query=query,
|
|
top_k=5,
|
|
prompt_template="compliance_qa",
|
|
)
|
|
|
|
async def generate() -> AsyncGenerator[str, None]:
|
|
"""Translate agent SSE events to compliance chunk/done format."""
|
|
for event in event_stream:
|
|
event_type = event.get("event", "")
|
|
if event_type == "content":
|
|
text = event.get("data", "")
|
|
if text:
|
|
yield (
|
|
"event: message\n"
|
|
f"data: {json.dumps({'type': 'chunk', 'text': text}, ensure_ascii=False)}\n\n"
|
|
)
|
|
elif event_type == "done":
|
|
yield (
|
|
"event: message\n"
|
|
f"data: {json.dumps({'type': 'done'}, ensure_ascii=False)}\n\n"
|
|
)
|
|
await asyncio.sleep(0)
|
|
|
|
return StreamingResponse(
|
|
generate(),
|
|
media_type="text/event-stream",
|
|
headers={"Cache-Control": "no-cache", "Connection": "keep-alive", "X-Accel-Buffering": "no"},
|
|
)
|