Refactor analyze endpoint to improve structure and add detailed response models for YouTube and file analysis

app/routes/analyze.py

@@ -1,36 +1,58 @@
 """
 General analysis route for CrownCode.
 Handles YouTube URLs and file uploads through a unified endpoint.
+Response format matches platform/hooks/analysisTypes.ts
 """
 
 from __future__ import annotations
 
+import time
 import uuid
-from typing import Optional, List, Dict, Any
-from fastapi import APIRouter, File, UploadFile, Form, HTTPException
-from pydantic import BaseModel
+from typing import Optional, List, Dict, Any, Literal
+from fastapi import APIRouter, File, UploadFile, Form
+from pydantic import BaseModel, Field
 
 from ..services.youtube_analysis import YouTubeAnalysisService
+from ..services.preview_model import PreviewModel
 from ..services.logging_config import get_logger
 
 router = APIRouter()
 logger = get_logger(__name__)
 youtube_service = YouTubeAnalysisService()
+preview_model = PreviewModel()
+
+
+# ============================================
+# Response Models - Platform Uyumlu
+# ============================================
+
+class AnalysisFeatures(BaseModel):
+    spectralRegularity: float = 0.5
+    temporalPatterns: float = 0.5
+    harmonicStructure: float = 0.5
+    artificialIndicators: List[str] = []
+
+
+class AudioInfo(BaseModel):
+    duration: float = 0.0
+    sampleRate: int = 44100
+    bitrate: int = 128
+    format: str = "unknown"
 
 
 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]
+    """Platform/hooks/analysisTypes.ts ile uyumlu"""
+    isAIGenerated: bool
+    confidence: float = Field(..., ge=0.0, le=1.0)
+    processingTime: float
+    modelVersion: str
+    decisionSource: Literal["music_ai", "ses_analizi", "preview"]
+    source: Dict[str, Any]
+    features: AnalysisFeatures
+    audioInfo: AudioInfo
 
 
 class AnalyzeResponse(BaseModel):
-    """Response structure matching frontend expectations."""
     result: Optional[AnalysisResult] = None
     warnings: List[str] = []
     errors: List[str] = []
@@ -42,96 +64,21 @@ async def analyze(
     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
-    """
+    """Unified analysis endpoint."""
     request_id = str(uuid.uuid4())[:8]
-    logger.info(f"[{request_id}] Analysis request: sourceType={sourceType}")
-
-    warnings: List[str] = []
-    errors: List[str] = []
+    start_time = time.monotonic()
+    logger.info(f"[{request_id}] Analysis: sourceType={sourceType}")
 
     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"])
+            return await _analyze_youtube(request_id, url, start_time)
 
         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)
+            return await _analyze_file(request_id, file, start_time)
 
         elif sourceType in ["spotify", "apple"]:
             return AnalyzeResponse(errors=["unsupported_source"])
@@ -140,5 +87,108 @@ async def analyze(
             return AnalyzeResponse(errors=["invalid_source_type"])
 
     except Exception as e:
-        logger.error(f"[{request_id}] Unexpected error: {e}", exc_info=True)
+        logger.error(f"[{request_id}] Error: {e}", exc_info=True)
         return AnalyzeResponse(errors=["internal_error"])
+
+
+async def _analyze_youtube(request_id: str, url: str, start_time: float) -> AnalyzeResponse:
+    """YouTube URL analizi."""
+    try:
+        yt_result = await youtube_service.analyze(url, include_raw=False)
+        processing_time = round(time.monotonic() - start_time, 3)
+
+        # Feature'ları preview model'den al
+        preview = preview_model.analyze(yt_result.source.video_id)
+        features_data = preview.get("features", {})
+
+        result = AnalysisResult(
+            isAIGenerated=yt_result.summary.is_ai_generated,
+            confidence=yt_result.summary.confidence,
+            processingTime=processing_time,
+            modelVersion=yt_result.summary.model_version,
+            decisionSource=yt_result.summary.decision_source,
+            source={
+                "kind": "youtube",
+                "url": url,
+                "normalizedUrl": yt_result.source.normalized_url,
+                "videoId": yt_result.source.video_id,
+                "startTimeSec": yt_result.source.start_time_sec
+            },
+            features=AnalysisFeatures(
+                spectralRegularity=features_data.get("spectral_regularity", 0.5),
+                temporalPatterns=features_data.get("temporal_patterns", 0.5),
+                harmonicStructure=features_data.get("harmonic_structure", 0.5),
+                artificialIndicators=yt_result.summary.indicators
+            ),
+            audioInfo=AudioInfo(
+                duration=yt_result.source.duration_sec or 0.0,
+                sampleRate=44100,
+                bitrate=128,
+                format=yt_result.source.audio_format or "unknown"
+            )
+        )
+
+        return AnalyzeResponse(
+            result=result,
+            warnings=yt_result.warnings,
+            errors=[]
+        )
+
+    except ValueError as e:
+        logger.warning(f"[{request_id}] Invalid URL: {e}")
+        return AnalyzeResponse(errors=["invalid_youtube_url"])
+    except Exception as e:
+        logger.error(f"[{request_id}] YouTube failed: {e}")
+        return AnalyzeResponse(errors=["youtube_analysis_failed"])
+
+
+async def _analyze_file(request_id: str, file: UploadFile, start_time: float) -> AnalyzeResponse:
+    """Dosya analizi."""
+    content_type = file.content_type or ""
+    if not content_type.startswith("audio/"):
+        return AnalyzeResponse(errors=["invalid_file_type"])
+
+    content = await file.read()
+    file_size = len(content)
+
+    if file_size > 30 * 1024 * 1024:
+        return AnalyzeResponse(errors=["file_too_large"])
+
+    if file_size < 1024:
+        return AnalyzeResponse(errors=["file_too_small"])
+
+    logger.info(f"[{request_id}] File: {file.filename} ({file_size / 1024 / 1024:.2f}MB)")
+
+    # Preview model ile analiz
+    fingerprint = f"file_{file.filename}_{file_size}"
+    preview = preview_model.analyze(fingerprint)
+    features_data = preview.get("features", {})
+    processing_time = round(time.monotonic() - start_time, 3)
+
+    result = AnalysisResult(
+        isAIGenerated=preview["is_ai_generated"],
+        confidence=preview["confidence"],
+        processingTime=processing_time,
+        modelVersion=preview["model_version"],
+        decisionSource="preview",
+        source={
+            "kind": "file",
+            "fileName": file.filename or "unknown",
+            "fileSizeBytes": file_size,
+            "mimeType": content_type
+        },
+        features=AnalysisFeatures(
+            spectralRegularity=features_data.get("spectral_regularity", 0.5),
+            temporalPatterns=features_data.get("temporal_patterns", 0.5),
+            harmonicStructure=features_data.get("harmonic_structure", 0.5),
+            artificialIndicators=preview.get("indicators", [])
+        ),
+        audioInfo=AudioInfo(
+            duration=0.0,
+            sampleRate=44100,
+            bitrate=128,
+            format=content_type.replace("audio/", "")
+        )
+    )
+
+    return AnalyzeResponse(result=result, warnings=[], errors=[])