splited methods for different object types

backend/app/api/routes.py

@@ -1,5 +1,3 @@
-"""API route handlers."""
-
 import logging
 from fastapi import APIRouter, HTTPException
 
@@ -8,8 +6,14 @@ from app.models.schemas import (
     AnalysisResponse,
     ErrorResponse,
     HealthResponse,
+    TextAnalysisRequest,
+    ImageAnalysisRequest,
+    VideoAnalysisRequest,
+    FileAnalysisRequest,
 )
 from app.services.download import download_file
+from app.services.text_analyzer import analyze_text
+from app.services.image_analyzer import analyze_image
 from app.services.detector import get_detector
 from app.core.config import get_settings
 from app.utils.exceptions import DeepfakeDetectionError
@@ -26,22 +30,18 @@ router = APIRouter()
     summary="Health check endpoint",
 )
 async def health_check() -> HealthResponse:
-    """
-    Health check endpoint to verify service is running.
-    
-    Returns:
-        Service status and version information
-    """
     settings = get_settings()
     logger.info("Health check endpoint accessed")
     
-    available_models = ["mock"]  # Add more as you implement them
+    available_models = ["mock"]
+    supported_types = ["text", "image", "video", "file"]
     
     return HealthResponse(
         status="ok",
         service="Deepfake Detection Service",
         version=settings.APP_VERSION,
         available_models=available_models,
+        supported_types=supported_types,
     )
 
 
@@ -54,75 +54,121 @@ async def health_check() -> HealthResponse:
         500: {"model": ErrorResponse, "description": "Internal server error"},
     },
     tags=["Analysis"],
-    summary="Analyze file for deepfake detection",
+    summary="Analyze content for deepfake detection",
 )
 async def analyze(request: AnalysisRequest) -> AnalysisResponse:
-    """
-    Analyze a file for deepfake detection.
+    settings = get_settings()
+    detector_model = None
     
-    Args:
-        request: AnalysisRequest containing file_url and optional model selection
+    if isinstance(request, TextAnalysisRequest):
+        detector_model = request.model or settings.DEFAULT_DETECTOR_MODEL
+        logger.info(f"Received text analysis request, length: {len(request.text)} chars, model: {detector_model}")
+        
+        try:
+            detector = get_detector(detector_model)
+        except ValueError as e:
+            logger.error(f"Invalid detector model: {str(e)}")
+            raise HTTPException(status_code=400, detail=str(e))
         
-    Returns:
-        AnalysisResponse with detection results
+        text_bytes = request.text.encode('utf-8')
+        analysis_result = await detector.detect(text_bytes)
         
-    Raises:
-        HTTPException: For various error conditions during processing
-    """
-    settings = get_settings()
-    detector_model = request.model or settings.DEFAULT_DETECTOR_MODEL
-    
-    logger.info(
-        f"Received analysis request for URL: {request.file_url} "
-        f"using model: {detector_model}"
-    )
-    
+        logger.info(f"Text analysis completed. Result: {analysis_result}")
+        
+        return AnalysisResponse(
+            is_deepfake=analysis_result["is_deepfake"],
+            confidence=analysis_result["confidence"],
+            analysis_time=analysis_result["analysis_time"],
+            model_used=detector_model,
+            content_type="text",
+        )
     
-    try:
+    elif isinstance(request, ImageAnalysisRequest):
+        detector_model = request.model or settings.DEFAULT_DETECTOR_MODEL
+        logger.info(f"Received image analysis request for URL: {request.image_url}, model: {detector_model}")
+        
         try:
             detector = get_detector(detector_model)
         except ValueError as e:
             logger.error(f"Invalid detector model: {str(e)}")
-            raise HTTPException(
-                status_code=400,
-                detail=str(e),
-            )
+            raise HTTPException(status_code=400, detail=str(e))
         
-        file_bytes = await download_file(str(request.file_url))
+        try:
+            image_bytes = await download_file(str(request.image_url))
+            if not image_bytes:
+                raise HTTPException(status_code=500, detail="Failed to download image")
+        except DeepfakeDetectionError as e:
+            raise HTTPException(status_code=e.status_code, detail=e.message)
         
-        if not file_bytes:
-            logger.error("File download returned empty bytes")
-            raise HTTPException(
-                status_code=500,
-                detail="Failed to download and process file",
-            )
+        analysis_result = await detector.detect(image_bytes)
         
-        analysis_result = await detector.detect(file_bytes)
+        logger.info(f"Image analysis completed. Result: {analysis_result}")
         
-        logger.info(
-            f"Analysis request completed successfully. "
-            f"File URL: {request.file_url}, Model: {detector_model}, "
-            f"Result: {analysis_result}"
+        return AnalysisResponse(
+            is_deepfake=analysis_result["is_deepfake"],
+            confidence=analysis_result["confidence"],
+            analysis_time=analysis_result["analysis_time"],
+            model_used=detector_model,
+            content_type="image",
         )
+    
+    elif isinstance(request, VideoAnalysisRequest):
+        detector_model = request.model or settings.DEFAULT_DETECTOR_MODEL
+        logger.info(f"Received video analysis request for URL: {request.video_url}, model: {detector_model}")
+        
+        try:
+            detector = get_detector(detector_model)
+        except ValueError as e:
+            logger.error(f"Invalid detector model: {str(e)}")
+            raise HTTPException(status_code=400, detail=str(e))
+        
+        try:
+            video_bytes = await download_file(str(request.video_url))
+            if not video_bytes:
+                raise HTTPException(status_code=500, detail="Failed to download video")
+        except DeepfakeDetectionError as e:
+            raise HTTPException(status_code=e.status_code, detail=e.message)
+        
+        analysis_result = await detector.detect(video_bytes)
+        
+        logger.info(f"Video analysis completed. Result: {analysis_result}")
         
         return AnalysisResponse(
             is_deepfake=analysis_result["is_deepfake"],
             confidence=analysis_result["confidence"],
             analysis_time=analysis_result["analysis_time"],
             model_used=detector_model,
+            content_type="video",
         )
+    
+    elif isinstance(request, FileAnalysisRequest):
+        detector_model = request.model or settings.DEFAULT_DETECTOR_MODEL
+        logger.info(f"Received file analysis request for URL: {request.file_url}, model: {detector_model}")
         
-    except HTTPException:
-        raise
-    except DeepfakeDetectionError as e:
-        logger.error(f"Detection error: {e.message}")
-        raise HTTPException(
-            status_code=e.status_code,
-            detail=e.message,
-        )
-    except Exception as e:
-        logger.error(f"Unexpected error during analysis: {str(e)}", exc_info=True)
-        raise HTTPException(
-            status_code=500,
-            detail="An unexpected error occurred during analysis. Please try again later.",
+        try:
+            detector = get_detector(detector_model)
+        except ValueError as e:
+            logger.error(f"Invalid detector model: {str(e)}")
+            raise HTTPException(status_code=400, detail=str(e))
+        
+        try:
+            file_bytes = await download_file(str(request.file_url))
+            if not file_bytes:
+                raise HTTPException(status_code=500, detail="Failed to download file")
+        except DeepfakeDetectionError as e:
+            raise HTTPException(status_code=e.status_code, detail=e.message)
+        
+        analysis_result = await detector.detect(file_bytes)
+        
+        logger.info(f"File analysis completed. Result: {analysis_result}")
+        
+        return AnalysisResponse(
+            is_deepfake=analysis_result["is_deepfake"],
+            confidence=analysis_result["confidence"],
+            analysis_time=analysis_result["analysis_time"],
+            model_used=detector_model,
+            content_type="file",
         )
+    
+    else:
+        raise HTTPException(status_code=400, detail="Unsupported content type")

backend/app/models/schemas.py

@@ -1,41 +1,81 @@
 from pydantic import BaseModel, HttpUrl, Field
-from typing import Optional
+from typing import Optional, Union, Literal
 
 
-class AnalysisRequest(BaseModel):
-    """Request model for deepfake analysis."""
+class TextAnalysisRequest(BaseModel):
+    content_type: Literal["text"]
+    text: str = Field(..., description="Text content to analyze for deepfake detection")
+    model: Optional[str] = Field(None, description="Detector model to use")
     
-    file_url: HttpUrl = Field(
-        ..., description="URL of the file to analyze for deepfake detection"
-    )
-    model: Optional[str] = Field(
-        None, description="Detector model to use (e.g., 'mock', 'deepseek', 'openai')"
-    )
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "content_type": "text",
+                "text": "Some text that might be AI-generated",
+                "model": "mock"
+            }
+        }
+
+
+class ImageAnalysisRequest(BaseModel):
+    content_type: Literal["image"]
+    image_url: HttpUrl = Field(..., description="URL of the image to analyze")
+    model: Optional[str] = Field(None, description="Detector model to use")
     
     class Config:
         json_schema_extra = {
             "example": {
+                "content_type": "image",
+                "image_url": "https://example.com/image.jpg",
+                "model": "mock"
+            }
+        }
+
+
+class VideoAnalysisRequest(BaseModel):
+    content_type: Literal["video"]
+    video_url: HttpUrl = Field(..., description="URL of the video to analyze")
+    model: Optional[str] = Field(None, description="Detector model to use")
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "content_type": "video",
+                "video_url": "https://example.com/video.mp4",
+                "model": "mock"
+            }
+        }
+
+
+class FileAnalysisRequest(BaseModel):
+    content_type: Literal["file"]
+    file_url: HttpUrl = Field(..., description="URL of the file to analyze")
+    model: Optional[str] = Field(None, description="Detector model to use")
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "content_type": "file",
                 "file_url": "https://example.com/video.mp4",
                 "model": "mock"
             }
         }
 
 
+AnalysisRequest = Union[
+    TextAnalysisRequest,
+    ImageAnalysisRequest,
+    VideoAnalysisRequest,
+    FileAnalysisRequest,
+]
+
+
 class AnalysisResponse(BaseModel):
-    """Response model for deepfake analysis results."""
-    
-    is_deepfake: bool = Field(
-        ..., description="Whether the file is detected as a deepfake"
-    )
-    confidence: float = Field(
-        ..., ge=0.0, le=1.0, description="Confidence score between 0.0 and 1.0"
-    )
-    analysis_time: float = Field(
-        ..., description="Time taken for analysis in seconds"
-    )
-    model_used: str = Field(
-        ..., description="The detector model that was used"
-    )
+    is_deepfake: bool = Field(..., description="Whether the content is detected as a deepfake")
+    confidence: float = Field(..., ge=0.0, le=1.0, description="Confidence score between 0.0 and 1.0")
+    analysis_time: float = Field(..., description="Time taken for analysis in seconds")
+    model_used: str = Field(..., description="The detector model that was used")
+    content_type: str = Field(..., description="Type of content analyzed (text/image/video/file)")
     
     class Config:
         json_schema_extra = {
@@ -43,34 +83,30 @@ class AnalysisResponse(BaseModel):
                 "is_deepfake": True,
                 "confidence": 0.847,
                 "analysis_time": 1.234,
-                "model_used": "mock"
+                "model_used": "mock",
+                "content_type": "image"
             }
         }
 
 
 class ErrorResponse(BaseModel):
-    """Response model for errors."""
-    
     error: str = Field(..., description="Error message")
     status_code: int = Field(..., description="HTTP status code")
-    details: Optional[str] = Field(
-        None, description="Additional error details"
-    )
+    details: Optional[str] = Field(None, description="Additional error details")
     
     class Config:
         json_schema_extra = {
             "example": {
                 "error": "Invalid URL format",
                 "status_code": 400,
-                "details": "The provided file_url is not a valid URL"
+                "details": "The provided URL is not valid"
             }
         }
 
 
 class HealthResponse(BaseModel):
-    """Response model for health check."""
-    
     status: str = Field(..., description="Service status")
     service: str = Field(..., description="Service name")
     version: str = Field(..., description="Service version")
     available_models: list = Field(..., description="Available detector models")
+    supported_types: list = Field(..., description="Supported content types")

backend/app/services/image_analyzer.py

@@ -0,0 +1,26 @@
+import logging
+import time
+from typing import Dict, Any
+
+logger = logging.getLogger(__name__)
+
+
+async def analyze_image(image_bytes: bytes) -> Dict[str, Any]:
+    start_time = time.time()
+    
+    logger.info(f"Starting image analysis, size: {len(image_bytes)} bytes")
+    
+    image_hash = hash(image_bytes) % 100
+    is_deepfake = image_hash > 50
+    confidence = (image_hash % 100) / 100.0
+    
+    analysis_time = time.time() - start_time
+    
+    result = {
+        "is_deepfake": is_deepfake,
+        "confidence": round(confidence, 3),
+        "analysis_time": round(analysis_time, 3),
+    }
+    
+    logger.info(f"Image analysis completed. Result: {result}")
+    return result

backend/app/services/text_analyzer.py

@@ -0,0 +1,26 @@
+import logging
+import time
+from typing import Dict, Any
+
+logger = logging.getLogger(__name__)
+
+
+async def analyze_text(text: str) -> Dict[str, Any]:
+    start_time = time.time()
+    
+    logger.info(f"Starting text analysis, length: {len(text)} chars")
+    
+    text_hash = hash(text) % 100
+    is_deepfake = text_hash > 50
+    confidence = (text_hash % 100) / 100.0
+    
+    analysis_time = time.time() - start_time
+    
+    result = {
+        "is_deepfake": is_deepfake,
+        "confidence": round(confidence, 3),
+        "analysis_time": round(analysis_time, 3),
+    }
+    
+    logger.info(f"Text analysis completed. Result: {result}")
+    return result