update flow poolling

app/api/v1/endpoints/report.py

@@ -1,19 +1,81 @@
 # app/api/v1/endpoints/report.py
 
-from fastapi import APIRouter
-from app.models.models import ReportRequest, ReportResponse
-from app.api.v1.dependencies import ReportServiceDep
+import asyncio
 import time
+from typing import Any, Optional
+from uuid import uuid4
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, Field
+
+from app.api.v1.dependencies import ReportServiceDep
+from app.models.models import ReportRequest
 
 router = APIRouter()
 
-@router.post("/report")
-async def get_report(
-    request: ReportRequest,
-    report_service: ReportServiceDep
-) -> ReportResponse:
+# In-memory job store for polling
+_jobs: dict[str, dict[str, Any]] = {}
+_tasks: dict[str, asyncio.Task] = {}
+_lock = asyncio.Lock()
+
+
+class ReportJobStatus(BaseModel):
+    job_id: str = Field(..., description="Polling job identifier")
+    status: str = Field(..., description="queued | processing | succeeded | failed")
+    readme_content: Optional[dict[str, Any]] = Field(None, description="Report content when completed")
+    processing_time: Optional[float] = Field(None, description="Processing time in seconds when completed")
+    error: Optional[str] = Field(None, description="Error message when failed")
+
+
+async def _run_report_job(job_id: str, request: ReportRequest, report_service: ReportServiceDep) -> None:
     start_time = time.time()
-    report = await report_service.generate_report(request)
-    end_time = time.time()
-    return ReportResponse(readme_content=report, processing_time=end_time - start_time)
-    
+    try:
+        result = await report_service.generate_report(request)
+        duration = time.time() - start_time
+        async with _lock:
+            _jobs[job_id].update({
+                "status": "succeeded",
+                "readme_content": result,
+                "processing_time": duration,
+            })
+    except Exception as exc:  # keep job record even if it fails
+        async with _lock:
+            _jobs[job_id].update({
+                "status": "failed",
+                "error": str(exc),
+            })
+
+
+@router.post("/report", response_model=ReportJobStatus)
+async def start_report_job(
+    request: ReportRequest,
+    report_service: ReportServiceDep,
+) -> ReportJobStatus:
+    job_id = uuid4().hex
+    async with _lock:
+        _jobs[job_id] = {
+            "job_id": job_id,
+            "status": "queued",
+            "readme_content": None,
+            "processing_time": None,
+            "error": None,
+        }
+    task = asyncio.create_task(_run_report_job(job_id, request, report_service))
+    _tasks[job_id] = task
+    async with _lock:
+        snapshot = _jobs[job_id].copy()
+    return ReportJobStatus(**snapshot)
+
+
+@router.get("/report/{job_id}", response_model=ReportJobStatus)
+async def get_report_job(job_id: str) -> ReportJobStatus:
+    async with _lock:
+        job = _jobs.get(job_id)
+        if not job:
+            raise HTTPException(status_code=404, detail="Job not found")
+        snapshot = job.copy()
+        # Clean up finished jobs to free memory
+        if snapshot["status"] in {"succeeded", "failed"}:
+            _jobs.pop(job_id, None)
+            _tasks.pop(job_id, None)
+    return ReportJobStatus(**snapshot)