config

backend/app/api/routes.py

@@ -1,5 +1,5 @@
 import logging
-from fastapi import APIRouter, HTTPException
+from fastapi import APIRouter, HTTPException, status
 
 from app.models.schemas import (
     AnalysisRequest,
@@ -8,8 +8,6 @@ from app.models.schemas import (
     HealthResponse,
     TextAnalysisRequest,
     ImageAnalysisRequest,
-    VideoAnalysisRequest,
-    FileAnalysisRequest,
 )
 from app.services.download import download_file
 from app.services.text_analyzer import analyze_text
@@ -21,21 +19,6 @@ logger = logging.getLogger(__name__)
 
 router = APIRouter()
 
-AVAILABLE_MODELS = {
-    "text": ["yaya36095/xlm-roberta-text-detector"],
-    "image": ["capcheck/ai-image-detection"],
-    "video": [],
-    "file": [],
-}
-
-MAX_CONTENT_SIZES = {
-    "text": 5000,
-    "image": 100 * 1024 * 1024,
-    "video": 100 * 1024 * 1024,
-    "file": 100 * 1024 * 1024,
-}
-
-
 @router.get(
     "/",
     response_model=HealthResponse,
@@ -46,186 +29,78 @@ async def health_check() -> HealthResponse:
     settings = get_settings()
     logger.info("Health check endpoint accessed")
     
-    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,
+        available_models=settings.AVAILABLE_MODELS,
+        supported_types=list(settings.AVAILABLE_MODELS.keys()),
     )
 
-
 @router.post(
     "/analyze",
     response_model=AnalysisResponse,
     responses={
         400: {"model": ErrorResponse, "description": "Bad request"},
         408: {"model": ErrorResponse, "description": "Request timeout"},
+        415: {"model": ErrorResponse, "description": "Unsupported media type"},
         500: {"model": ErrorResponse, "description": "Internal server error"},
     },
     tags=["Analysis"],
     summary="Analyze content for deepfake detection",
 )
 async def analyze(request: AnalysisRequest) -> AnalysisResponse:
-    settings = get_settings()
-    
     if isinstance(request, TextAnalysisRequest):
         content_type = "text"
-        
-        if len(request.text) > MAX_CONTENT_SIZES["text"]:
-            raise HTTPException(
-                status_code=400,
-                detail=f"Text content exceeds maximum length of {MAX_CONTENT_SIZES['text']} characters"
-            )
-        
-        if len(request.text) < 50:
-            raise HTTPException(
-                status_code=400,
-                detail="Text content must be at least 50 characters"
-            )
-        
-        if not AVAILABLE_MODELS["text"]:
-            raise HTTPException(
-                status_code=400,
-                detail="No model available for text analysis"
-            )
-        
-        model = AVAILABLE_MODELS["text"][0]
-        logger.info(f"Received text analysis request, length: {len(request.text)} chars, model: {model}")
-        
-        try:
-            analysis_result = await analyze_text(request.text)
-        except ValueError as e:
-            raise HTTPException(status_code=400, detail=str(e))
-        except Exception as e:
-            logger.error(f"Text analysis error: {str(e)}", exc_info=True)
-            raise HTTPException(status_code=500, detail="Failed to analyze text")
-        
-        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=model,
-            content_type="text",
-        )
-    
     elif isinstance(request, ImageAnalysisRequest):
         content_type = "image"
-        
-        if not AVAILABLE_MODELS["image"]:
-            raise HTTPException(
-                status_code=400,
-                detail="No model available for image analysis"
-            )
-        
-        model = AVAILABLE_MODELS["image"][0]
-        logger.info(f"Received image analysis request for URL: {request.image_url}, model: {model}")
-        
-        try:
-            image_bytes = await download_file(str(request.image_url))
-            if not image_bytes:
-                raise HTTPException(status_code=500, detail="Failed to download image")
-            
-            if len(image_bytes) > MAX_CONTENT_SIZES["image"]:
-                raise HTTPException(
-                    status_code=400,
-                    detail=f"Image size exceeds maximum of {MAX_CONTENT_SIZES['image']} bytes"
-                )
-            
-        except DeepfakeDetectionError as e:
-            raise HTTPException(status_code=e.status_code, detail=e.message)
-        
-        analysis_result = await analyze_image(image_bytes)
-        
-        logger.info(f"Image 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=model,
-            content_type="image",
-        )
-    
-    elif isinstance(request, VideoAnalysisRequest):
-        content_type = "video"
-        
-        if not AVAILABLE_MODELS["video"]:
-            raise HTTPException(
-                status_code=400,
-                detail="No model available for video analysis"
-            )
-        
-        model = AVAILABLE_MODELS["video"][0]
-        logger.info(f"Received video analysis request for URL: {request.video_url}, model: {model}")
-        
-        try:
-            video_bytes = await download_file(str(request.video_url))
-            if not video_bytes:
-                raise HTTPException(status_code=500, detail="Failed to download video")
-            
-            if len(video_bytes) > MAX_CONTENT_SIZES["video"]:
-                raise HTTPException(
-                    status_code=400,
-                    detail=f"Video size exceeds maximum of {MAX_CONTENT_SIZES['video']} bytes"
-                )
-            
-        except DeepfakeDetectionError as e:
-            raise HTTPException(status_code=e.status_code, detail=e.message)
-        
-        analysis_result = await analyze_image(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=model,
-            content_type="video",
+    else:
+        raise HTTPException(
+            status_code=status.HTTP_415_UNSUPPORTED_MEDIA_TYPE, 
+            detail="Unsupported file/content type. Only text and image are currently supported."
         )
+
+    settings = get_settings()
+    models = settings.AVAILABLE_MODELS.get(content_type)
+    if not models:
+        raise HTTPException(status_code=400, detail=f"No model available for {content_type} analysis")
     
-    elif isinstance(request, FileAnalysisRequest):
-        content_type = "file"
-        
-        if not AVAILABLE_MODELS["file"]:
-            raise HTTPException(
-                status_code=400,
-                detail="No model available for file analysis"
-            )
-        
-        model = AVAILABLE_MODELS["file"][0]
-        logger.info(f"Received file analysis request for URL: {request.file_url}, model: {model}")
-        
-        try:
-            file_bytes = await download_file(str(request.file_url))
-            if not file_bytes:
-                raise HTTPException(status_code=500, detail="Failed to download file")
+    model = models[0]
+    logger.info(f"Received {content_type} analysis request, model: {model}")
+
+    try:
+        if content_type == "text":
+            if len(request.text) > settings.MAX_CONTENT_SIZES["text"]:
+                raise ValueError(f"Text content exceeds maximum length of {settings.MAX_CONTENT_SIZES['text']} characters")
+            if len(request.text) < 50:
+                raise ValueError("Text content must be at least 50 characters")
             
-            if len(file_bytes) > MAX_CONTENT_SIZES["file"]:
-                raise HTTPException(
-                    status_code=400,
-                    detail=f"File size exceeds maximum of {MAX_CONTENT_SIZES['file']} bytes"
-                )
+            analysis_result = await analyze_text(request.text)
+
+        elif content_type == "image":
+            image_bytes = await download_file(str(request.image_url))
+            if not image_bytes:
+                raise ValueError("Failed to download image")
+            if len(image_bytes) > settings.MAX_CONTENT_SIZES["image"]:
+                raise ValueError(f"Image size exceeds maximum of {settings.MAX_CONTENT_SIZES['image']} bytes")
             
-        except DeepfakeDetectionError as e:
-            raise HTTPException(status_code=e.status_code, detail=e.message)
-        
-        analysis_result = await analyze_image(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=model,
-            content_type="file",
-        )
+            analysis_result = await analyze_image(image_bytes)
+
+    # 4. Globalna obsługa błędów
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except DeepfakeDetectionError as e:
+        raise HTTPException(status_code=e.status_code, detail=e.message)
+    except Exception as e:
+        logger.error(f"{content_type.capitalize()} analysis error: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Failed to analyze {content_type}")
+
+    logger.info(f"{content_type.capitalize()} analysis completed. Result: {analysis_result}")
     
-    else:
-        raise HTTPException(status_code=400, detail="Unsupported content type")
+    return AnalysisResponse(
+        is_deepfake=analysis_result["is_deepfake"],
+        confidence=analysis_result["confidence"],
+        analysis_time=analysis_result["analysis_time"],
+        model_used=model,
+        content_type=content_type,
+    )

backend/app/core/config.py

@@ -31,6 +31,16 @@ class Settings:
     # Logging
     LOG_LEVEL: str = os.getenv("LOG_LEVEL", "INFO")
     LOG_FILE: Optional[str] = os.getenv("LOG_FILE", None)
+    
+    AVAILABLE_MODELS = {
+        "text": ["yaya36095/xlm-roberta-text-detector"],
+        "image": ["capcheck/ai-image-detection"],
+    }
+
+    MAX_CONTENT_SIZES = {
+        "text": 5000,
+        "image": 100 * 1024 * 1024,
+    }
 
 
 @lru_cache()