Add unified analysis endpoint for YouTube URLs and file uploads

app/routes/analyze.py

@@ -0,0 +1,144 @@
+"""
+General analysis route for CrownCode.
+Handles YouTube URLs and file uploads through a unified endpoint.
+"""
+
+from __future__ import annotations
+
+import uuid
+from typing import Optional, List, Dict, Any
+from fastapi import APIRouter, File, UploadFile, Form, HTTPException
+from pydantic import BaseModel
+
+from ..services.youtube_analysis import YouTubeAnalysisService
+from ..services.logging_config import get_logger
+
+router = APIRouter()
+logger = get_logger(__name__)
+youtube_service = YouTubeAnalysisService()
+
+
+class AnalysisResult(BaseModel):
+    """Unified analysis result structure."""
+    request_id: str
+    source_type: str
+    is_ai_generated: bool
+    confidence: float
+    model_version: str
+    indicators: List[str]
+    metadata: Dict[str, Any]
+
+
+class AnalyzeResponse(BaseModel):
+    """Response structure matching frontend expectations."""
+    result: Optional[AnalysisResult] = None
+    warnings: List[str] = []
+    errors: List[str] = []
+
+
+@router.post("/api/analyze", response_model=AnalyzeResponse)
+async def analyze(
+    sourceType: str = Form(...),
+    url: Optional[str] = Form(None),
+    file: Optional[UploadFile] = File(None)
+) -> AnalyzeResponse:
+    """
+    Unified analysis endpoint.
+
+    Args:
+        sourceType: Type of source (youtube, file, spotify, apple)
+        url: URL for YouTube/Spotify/Apple Music
+        file: Uploaded audio file
+
+    Returns:
+        AnalyzeResponse with result or errors
+    """
+    request_id = str(uuid.uuid4())[:8]
+    logger.info(f"[{request_id}] Analysis request: sourceType={sourceType}")
+
+    warnings: List[str] = []
+    errors: List[str] = []
+
+    try:
+        if sourceType == "youtube":
+            if not url:
+                return AnalyzeResponse(errors=["missing_url"])
+
+            # Use YouTube analysis service
+            try:
+                yt_result = await youtube_service.analyze(url, include_raw=False)
+
+                result = AnalysisResult(
+                    request_id=request_id,
+                    source_type="youtube",
+                    is_ai_generated=yt_result.summary.is_ai_generated,
+                    confidence=yt_result.summary.confidence,
+                    model_version=yt_result.summary.model_version,
+                    indicators=yt_result.summary.indicators,
+                    metadata={
+                        "video_id": yt_result.source.video_id,
+                        "title": yt_result.source.title,
+                        "duration_sec": yt_result.source.duration_sec,
+                        "decision_source": yt_result.summary.decision_source
+                    }
+                )
+
+                return AnalyzeResponse(
+                    result=result,
+                    warnings=yt_result.warnings,
+                    errors=yt_result.errors
+                )
+
+            except ValueError as e:
+                logger.warning(f"[{request_id}] YouTube analysis error: {e}")
+                return AnalyzeResponse(errors=["invalid_youtube_url"])
+            except Exception as e:
+                logger.error(f"[{request_id}] YouTube analysis failed: {e}")
+                return AnalyzeResponse(errors=["youtube_analysis_failed"])
+
+        elif sourceType == "file":
+            if not file:
+                return AnalyzeResponse(errors=["missing_file"])
+
+            # Validate file type
+            if not file.content_type or not file.content_type.startswith("audio/"):
+                return AnalyzeResponse(errors=["invalid_file_type"])
+
+            # Read file content
+            content = await file.read()
+            file_size_mb = len(content) / (1024 * 1024)
+
+            if file_size_mb > 30:
+                return AnalyzeResponse(errors=["file_too_large"])
+
+            logger.info(f"[{request_id}] Processing file: {file.filename} ({file_size_mb:.2f}MB)")
+
+            # TODO: Implement actual audio analysis
+            # For now, return a placeholder result
+            warnings.append("file_analysis_not_implemented")
+
+            result = AnalysisResult(
+                request_id=request_id,
+                source_type="file",
+                is_ai_generated=False,
+                confidence=0.0,
+                model_version="placeholder",
+                indicators=["file_analysis_pending"],
+                metadata={
+                    "filename": file.filename,
+                    "size_mb": round(file_size_mb, 2),
+                    "content_type": file.content_type
+                }
+            )
+
+            return AnalyzeResponse(result=result, warnings=warnings)
+
+        elif sourceType in ["spotify", "apple"]:
+            return AnalyzeResponse(errors=["unsupported_source"])
+
+        else:
+            return AnalyzeResponse(errors=["invalid_source_type"])
+
+    except Exception as e:
+        logger.error(f"[{request_id}] Unexpected error: {e}", exc_info=True)
+        return AnalyzeResponse(errors=["internal_error"])