Merge pull request #1 from Tobkubos/backend-setup

QUICKSTART.md

@@ -0,0 +1,49 @@
+# Quick Reference Guide
+
+## 🚀 Starting the Backend
+
+### First Time Setup (Windows)
+```powershell
+cd backend
+python setup.py
+venv\Scripts\activate
+python main.py
+```
+
+### First Time Setup (macOS/Linux)
+```bash
+cd backend
+python setup.py
+source venv/bin/activate
+python main.py
+
+or 
+
+"uvicorn app:app --reload --host 127.0.0.1 --port 8000"
+"uvicorn app:app --host 127.0.0.1 --port 8000"
+```
+
+### Subsequent Times
+```bash
+cd backend
+run.bat
+```
+
+## 📡 API Quick Test
+
+### Health Check
+```bash
+curl http://localhost:8000/
+```
+
+### Analyze a File
+```bash
+curl -X POST http://localhost:8000/analyze \
+  -H "Content-Type: application/json" \
+  -d '{"file_url": "https://example.com/video.mp4"}'
+```
+
+### Documentation
+- **Swagger UI**: http://localhost:8000/docs
+- **ReDoc**: http://localhost:8000/redoc
+

README.md

@@ -1 +0,0 @@
-# DiscordBot

TODO.md

@@ -0,0 +1,2 @@
+Bezpieczeństwo (SSRF - Server-Side Request Forgery): Twój backend pobiera pliki z dowolnego przekazanego adresu URL. Złośliwy użytkownik mógłby podać URL wskazujący na wewnętrzne zasoby Twojej sieci (np. http://localhost:8080/admin). Warto zaimplementować w download_file walidację, która pozwala na pobieranie plików wyłącznie z zaufanych domen (np. tylko z *.discordapp.com i *.media.discordapp.net).
+

backend/.env.example

@@ -0,0 +1,28 @@
+# Deepfake Detection Service - Environment Variables
+
+# Application Settings
+APP_NAME=Deepfake Detection Service
+APP_VERSION=1.0.0
+DEBUG=True
+RELOAD=True
+
+# Server Configuration
+HOST=127.0.0.1
+PORT=8000
+
+# File Handling
+DOWNLOAD_TIMEOUT=30
+MAX_FILE_SIZE=104857600
+
+# ML Model Configuration
+DEFAULT_DETECTOR_MODEL=mock
+# Supported models: mock, deepseek, openai, etc.
+
+# Redis Configuration (for future queuing)
+REDIS_ENABLED=False
+REDIS_URL=redis://localhost:6379
+REDIS_QUEUE_NAME=deepfake_analysis
+
+# Logging
+LOG_LEVEL=INFO
+LOG_FILE=

backend/.gitignore

@@ -0,0 +1,57 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environments
+venv/
+ENV/
+env/
+.venv
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store
+
+# Environment variables
+.env
+.env.local
+.env.*.local
+
+# Logs
+logs/
+*.log
+*.log.*
+
+# Redis
+dump.rdb
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Temporary files
+*.tmp
+*.temp

backend/README.md

@@ -0,0 +1,133 @@
+# Deepfake Detection Service Backend
+
+### Prerequisites
+- Python 3.8+
+- pip or conda
+
+### Installation
+
+1. **Navigate to the backend directory:**
+   ```bash
+   cd backend
+   ```
+
+2. **Create a virtual environment (recommended):**
+   ```bash
+   # Using venv
+   python -m venv venv
+   
+   # Activate virtual environment
+   # On Windows:
+   venv\Scripts\activate
+   # On macOS/Linux:
+   source venv/bin/activate
+   ```
+
+3. **Install dependencies:**
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+4. **Run the server:**
+   ```bash
+   python main.py
+   ```
+
+The server will start on `http://127.0.0.1:8000`
+
+## 📖 API Documentation
+
+Once the server is running, interactive API documentation is available at:
+- Swagger UI: `http://127.0.0.1:8000/docs`
+- ReDoc: `http://127.0.0.1:8000/redoc`
+
+## 🔌 API Endpoints
+
+### Health Check
+```bash
+GET /
+```
+
+Returns service status and available models.
+
+**Response:**
+```json
+{
+  "status": "ok",
+  "service": "Deepfake Detection Service",
+  "version": "1.0.0",
+  "available_models": ["mock"]
+}
+```
+
+### Analyze File
+```bash
+POST /analyze
+Content-Type: application/json
+
+{
+  "file_url": "https://example.com/video.mp4",
+  "model": "mock"
+}
+```
+
+**Request Parameters:**
+- `file_url` (required): URL of the file to analyze
+- `model` (optional): Detector model to use. Defaults to configured model
+
+**Response (200 OK):**
+```json
+{
+  "is_deepfake": true,
+  "confidence": 0.847,
+  "analysis_time": 1.234,
+  "model_used": "mock"
+}
+```
+
+**Error Responses:**
+- `400 Bad Request`: Invalid URL, file too large, or unsupported model
+- `408 Request Timeout`: File download timed out
+- `500 Internal Server Error`: Server error during analysis
+
+
+### Using curl:
+```bash
+curl -X POST http://localhost:8000/analyze \
+  -H "Content-Type: application/json" \
+  -d '{"file_url": "https://example.com/video.mp4"}'
+```
+
+
+The API provides comprehensive error handling:
+
+```python
+# Invalid URL
+{
+  "error": "Invalid URL format",
+  "status_code": 400,
+  "details": null
+}
+
+# File too large
+{
+  "error": "File size exceeds maximum allowed size of 104857600 bytes",
+  "status_code": 400,
+  "details": null
+}
+
+# Download timeout
+{
+  "error": "File download timed out",
+  "status_code": 408,
+  "details": null
+}
+
+# Unsupported model
+{
+  "error": "Detector model 'invalid' is not supported. Available models: mock",
+  "status_code": 400,
+  "details": null
+}
+```
+

backend/app/__init__.py

@@ -0,0 +1,13 @@
+from fastapi import FastAPI
+from app.api.routes import router as api_router
+from app.core.logging_config import setup_logging
+
+setup_logging()
+
+app = FastAPI(
+    title="Deepfake Detection Service",
+    description="Backend service for deepfake detection with support for multiple ML models",
+    version="1.0.0",
+)
+
+app.include_router(api_router)

backend/app/api/__init__.py

@@ -0,0 +1 @@
+"""API routes and endpoints."""

backend/app/api/routes.py

@@ -0,0 +1,174 @@
+import logging
+from fastapi import APIRouter, HTTPException
+
+from app.models.schemas import (
+    AnalysisRequest,
+    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
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+@router.get(
+    "/",
+    response_model=HealthResponse,
+    tags=["Health"],
+    summary="Health check endpoint",
+)
+async def health_check() -> HealthResponse:
+    settings = get_settings()
+    logger.info("Health check endpoint accessed")
+    
+    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,
+    )
+
+
+@router.post(
+    "/analyze",
+    response_model=AnalysisResponse,
+    responses={
+        400: {"model": ErrorResponse, "description": "Bad request"},
+        408: {"model": ErrorResponse, "description": "Request timeout"},
+        500: {"model": ErrorResponse, "description": "Internal server error"},
+    },
+    tags=["Analysis"],
+    summary="Analyze content for deepfake detection",
+)
+async def analyze(request: AnalysisRequest) -> AnalysisResponse:
+    settings = get_settings()
+    detector_model = None
+    
+    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))
+        
+        text_bytes = request.text.encode('utf-8')
+        analysis_result = await detector.detect(text_bytes)
+        
+        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",
+        )
+    
+    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))
+        
+        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)
+        
+        analysis_result = await detector.detect(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=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}")
+        
+        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/core/__init__.py

@@ -0,0 +1 @@
+"""Core application configuration and setup."""

backend/app/core/config.py

@@ -0,0 +1,39 @@
+import os
+from typing import Optional
+from functools import lru_cache
+
+
+class Settings:
+    """Application settings with environment variable support."""
+    
+    # Application
+    APP_NAME: str = "Deepfake Detection Service"
+    APP_VERSION: str = "1.0.0"
+    DEBUG: bool = os.getenv("DEBUG", "True").lower() == "true"
+    
+    # Server
+    HOST: str = os.getenv("HOST", "127.0.0.1")
+    PORT: int = int(os.getenv("PORT", "8000"))
+    
+    # File handling
+    DOWNLOAD_TIMEOUT: int = int(os.getenv("DOWNLOAD_TIMEOUT", "30"))
+    MAX_FILE_SIZE: int = int(os.getenv("MAX_FILE_SIZE", str(100 * 1024 * 1024)))  # 100 MB
+    
+    # ML Model configuration
+    DEFAULT_DETECTOR_MODEL: str = os.getenv("DEFAULT_DETECTOR_MODEL", "mock")
+    # Supported models: "mock", "deepseek", "openai", etc. (easy to add more)
+    
+    # Redis configuration (for future queuing)
+    REDIS_ENABLED: bool = os.getenv("REDIS_ENABLED", "False").lower() == "true"
+    REDIS_URL: str = os.getenv("REDIS_URL", "redis://localhost:6379")
+    REDIS_QUEUE_NAME: str = os.getenv("REDIS_QUEUE_NAME", "deepfake_analysis")
+    
+    # Logging
+    LOG_LEVEL: str = os.getenv("LOG_LEVEL", "INFO")
+    LOG_FILE: Optional[str] = os.getenv("LOG_FILE", None)
+
+
+@lru_cache()
+def get_settings() -> Settings:
+    """Get cached application settings."""
+    return Settings()

backend/app/core/logging_config.py

@@ -0,0 +1,35 @@
+import logging
+import logging.handlers
+from app.core.config import get_settings
+
+
+def setup_logging():
+    """Configure logging for the application."""
+    settings = get_settings()
+    
+    # Create logger
+    logger = logging.getLogger()
+    logger.setLevel(getattr(logging, settings.LOG_LEVEL))
+    
+    # Remove existing handlers
+    logger.handlers.clear()
+    
+    # Console handler
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(getattr(logging, settings.LOG_LEVEL))
+    formatter = logging.Formatter(
+        "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    )
+    console_handler.setFormatter(formatter)
+    logger.addHandler(console_handler)
+    
+    # File handler (if specified)
+    if settings.LOG_FILE:
+        file_handler = logging.handlers.RotatingFileHandler(
+            settings.LOG_FILE,
+            maxBytes=10485760,  # 10 MB
+            backupCount=5,
+        )
+        file_handler.setLevel(getattr(logging, settings.LOG_LEVEL))
+        file_handler.setFormatter(formatter)
+        logger.addHandler(file_handler)

backend/app/models/__init__.py

@@ -0,0 +1 @@
+"""Data models and schemas."""

backend/app/models/schemas.py

@@ -0,0 +1,112 @@
+from pydantic import BaseModel, HttpUrl, Field
+from typing import Optional, Union, Literal
+
+
+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")
+    
+    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):
+    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 = {
+            "example": {
+                "is_deepfake": True,
+                "confidence": 0.847,
+                "analysis_time": 1.234,
+                "model_used": "mock",
+                "content_type": "image"
+            }
+        }
+
+
+class ErrorResponse(BaseModel):
+    error: str = Field(..., description="Error message")
+    status_code: int = Field(..., description="HTTP status code")
+    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 URL is not valid"
+            }
+        }
+
+
+class HealthResponse(BaseModel):
+    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/__init__.py

@@ -0,0 +1 @@
+"""Service layer for business logic."""

backend/app/services/detector/__init__.py

@@ -0,0 +1,37 @@
+"""Detector models for deepfake detection."""
+
+from app.services.detector.base import BaseDetector
+from app.services.detector.mock import MockDetector
+
+__all__ = ["BaseDetector", "MockDetector", "get_detector"]
+
+
+def get_detector(model_name: str = "mock") -> BaseDetector:
+    """
+    Factory function to get detector instance by model name.
+    
+    Args:
+        model_name: Name of the detector model
+        
+    Returns:
+        Instance of the requested detector
+        
+    Raises:
+        ValueError: If model is not supported
+    """
+    detectors = {
+        "mock": MockDetector,
+        # Future models:
+        # "deepseek": DeepseekDetector,
+        # "openai": OpenAIDetector,
+        # "huggingface": HuggingFaceDetector,
+    }
+    
+    if model_name not in detectors:
+        available = ", ".join(detectors.keys())
+        raise ValueError(
+            f"Detector model '{model_name}' is not supported. "
+            f"Available models: {available}"
+        )
+    
+    return detectors[model_name]()

backend/app/services/detector/base.py

@@ -0,0 +1,38 @@
+"""Base detector class defining the interface for all detectors."""
+
+from abc import ABC, abstractmethod
+from typing import Dict, Any
+
+
+class BaseDetector(ABC):
+    """
+    Abstract base class for deepfake detectors.
+    
+    All detector implementations should inherit from this class and implement
+    the detect() method.
+    """
+    
+    def __init__(self, model_name: str):
+        """
+        Initialize the detector.
+        
+        Args:
+            model_name: Name of the detector model
+        """
+        self.model_name = model_name
+    
+    @abstractmethod
+    async def detect(self, file_bytes: bytes) -> Dict[str, Any]:
+        """
+        Detect if file is a deepfake.
+        
+        Args:
+            file_bytes: The file contents as bytes
+            
+        Returns:
+            Dictionary containing:
+            - is_deepfake: Boolean indicating if file is a deepfake
+            - confidence: Float between 0.0 and 1.0
+            - analysis_time: Float representing processing time
+        """
+        pass

backend/app/services/detector/mock.py

@@ -0,0 +1,56 @@
+"""Mock detector implementation for testing and development."""
+
+import asyncio
+import logging
+import time
+from typing import Dict, Any
+
+from app.services.detector.base import BaseDetector
+
+logger = logging.getLogger(__name__)
+
+
+class MockDetector(BaseDetector):
+    """
+    Mock detector for testing and development.
+    
+    Simulates deepfake detection without requiring actual ML models.
+    """
+    
+    def __init__(self):
+        """Initialize the mock detector."""
+        super().__init__("mock")
+    
+    async def detect(self, file_bytes: bytes) -> Dict[str, Any]:
+        """
+        Simulate deepfake detection with a random result.
+        
+        Args:
+            file_bytes: The file contents as bytes
+            
+        Returns:
+            Dictionary with is_deepfake, confidence, and analysis_time
+        """
+        logger.info("Starting mock deepfake analysis...")
+        
+        start_time = time.time()
+        
+        # Simulate processing delay (1 to 2 seconds)
+        delay = 1.0 + (hash(file_bytes) % 100) / 100.0
+        await asyncio.sleep(delay)
+        
+        analysis_time = time.time() - start_time
+        
+        # Simulate ML model output (deterministic based on file content hash)
+        file_hash = hash(file_bytes) % 100
+        is_deepfake = file_hash > 50  # ~50% chance
+        confidence = (file_hash % 100) / 100.0
+        
+        result = {
+            "is_deepfake": is_deepfake,
+            "confidence": round(confidence, 3),
+            "analysis_time": round(analysis_time, 3),
+        }
+        
+        logger.info(f"Mock analysis completed. Result: {result}")
+        return result

backend/app/services/download.py

@@ -0,0 +1,92 @@
+import logging
+import httpx
+
+from app.core.config import get_settings
+from app.utils.exceptions import (
+    FileDownloadError,
+    InvalidURLError,
+    DownloadTimeoutError,
+    FileSizeError,
+)
+
+logger = logging.getLogger(__name__)
+
+
+async def download_file(file_url: str) -> bytes:
+    """
+    Asynchronously download a file from the given URL.
+    
+    Args:
+        file_url: The URL of the file to download
+        
+    Returns:
+        The file contents as bytes
+        
+    Raises:
+        InvalidURLError: If the URL is invalid
+        DownloadTimeoutError: If download times out
+        FileSizeError: If file size exceeds limit
+        FileDownloadError: If download fails for other reasons
+    """
+    settings = get_settings()
+    logger.info(f"Starting file download from: {file_url}")
+    
+    try:
+        async with httpx.AsyncClient(timeout=settings.DOWNLOAD_TIMEOUT) as client:
+            response = await client.get(file_url, follow_redirects=True)
+            
+            # Check for HTTP errors
+            if response.status_code != 200:
+                logger.error(
+                    f"Failed to download file. Status code: {response.status_code}"
+                )
+                raise FileDownloadError(
+                    f"Failed to download file. Server returned status code {response.status_code}",
+                    status_code=response.status_code,
+                )
+            
+            # Check content length header
+            content_length = response.headers.get("content-length")
+            if content_length and int(content_length) > settings.MAX_FILE_SIZE:
+                logger.error(
+                    f"File size exceeds maximum allowed size: {content_length} bytes"
+                )
+                raise FileSizeError(
+                    f"File size exceeds maximum allowed size of {settings.MAX_FILE_SIZE} bytes"
+                )
+            
+            file_bytes = response.content
+            
+            # Check actual content size
+            if len(file_bytes) > settings.MAX_FILE_SIZE:
+                logger.error(
+                    f"Downloaded file exceeds maximum size: {len(file_bytes)} bytes"
+                )
+                raise FileSizeError(
+                    f"File size exceeds maximum allowed size of {settings.MAX_FILE_SIZE} bytes"
+                )
+            
+            logger.info(
+                f"File download completed successfully. Size: {len(file_bytes)} bytes"
+            )
+            return file_bytes
+            
+    except httpx.InvalidURL as e:
+        logger.error(f"Invalid URL provided: {file_url} - {str(e)}")
+        raise InvalidURLError("Invalid URL format")
+    except httpx.TimeoutException as e:
+        logger.error(f"Download timeout for URL: {file_url}")
+        raise DownloadTimeoutError("File download timed out. Please try again with a faster source.")
+    except (FileSizeError, InvalidURLError, DownloadTimeoutError):
+        # Re-raise custom exceptions
+        raise
+    except httpx.RequestError as e:
+        logger.error(f"Failed to download file from {file_url}: {str(e)}")
+        raise FileDownloadError(
+            "Failed to download file from the provided URL. Please check the URL and try again."
+        )
+    except Exception as e:
+        logger.error(f"Unexpected error during file download: {str(e)}")
+        raise FileDownloadError(
+            "An unexpected error occurred during file download."
+        )

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/queue.py

@@ -0,0 +1,97 @@
+import logging
+from typing import Optional, Any, Dict
+import json
+
+from app.core.config import get_settings
+
+logger = logging.getLogger(__name__)
+
+
+class QueueService:
+    """
+    Queue service for managing asynchronous analysis tasks.
+    
+    Currently uses in-memory queue, can be extended to use Redis.
+    """
+    
+    def __init__(self):
+        """Initialize the queue service."""
+        self.settings = get_settings()
+        self.redis_client = None
+        
+        if self.settings.REDIS_ENABLED:
+            self._initialize_redis()
+    
+    def _initialize_redis(self):
+        """Initialize Redis connection (future implementation)."""
+        # This will be implemented when Redis support is added
+        logger.info(
+            f"Redis queue service initialized: {self.settings.REDIS_URL}"
+        )
+    
+    async def enqueue_analysis(
+        self,
+        file_url: str,
+        model: str,
+        task_id: str,
+    ) -> bool:
+        """
+        Enqueue an analysis task.
+        
+        Args:
+            file_url: URL of the file to analyze
+            model: Detector model to use
+            task_id: Unique task identifier
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        task_data = {
+            "task_id": task_id,
+            "file_url": file_url,
+            "model": model,
+        }
+        
+        logger.info(f"Enqueuing analysis task: {task_id}")
+        
+        if self.settings.REDIS_ENABLED:
+            # Future: Push to Redis queue
+            # await self.redis_client.lpush(
+            #     self.settings.REDIS_QUEUE_NAME,
+            #     json.dumps(task_data)
+            # )
+            pass
+        
+        return True
+    
+    async def get_task_result(self, task_id: str) -> Optional[Dict[str, Any]]:
+        """
+        Get analysis result for a task.
+        
+        Args:
+            task_id: Task identifier
+            
+        Returns:
+            Analysis result or None if not found
+        """
+        logger.info(f"Retrieving result for task: {task_id}")
+        
+        if self.settings.REDIS_ENABLED:
+            # Future: Get from Redis
+            # result = await self.redis_client.get(f"result:{task_id}")
+            # return json.loads(result) if result else None
+            pass
+        
+        return None
+
+
+# Singleton instance
+_queue_service: Optional[QueueService] = None
+
+
+def get_queue_service() -> QueueService:
+    """Get or create the queue service singleton."""
+    global _queue_service
+    if _queue_service is None:
+        _queue_service = QueueService()
+    return _queue_service

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

backend/app/utils/__init__.py

@@ -0,0 +1 @@
+"""Utility functions and exception classes."""

backend/app/utils/exceptions.py

@@ -0,0 +1,53 @@
+"""Custom exception classes."""
+
+
+class DeepfakeDetectionError(Exception):
+    """Base exception for deepfake detection service."""
+    
+    def __init__(self, message: str, status_code: int = 500):
+        self.message = message
+        self.status_code = status_code
+        super().__init__(self.message)
+
+
+class FileDownloadError(DeepfakeDetectionError):
+    """Exception raised when file download fails."""
+    
+    def __init__(self, message: str, status_code: int = 400):
+        super().__init__(message, status_code)
+
+
+class InvalidURLError(DeepfakeDetectionError):
+    """Exception raised when URL is invalid."""
+    
+    def __init__(self, message: str = "Invalid URL format"):
+        super().__init__(message, 400)
+
+
+class DownloadTimeoutError(DeepfakeDetectionError):
+    """Exception raised when file download times out."""
+    
+    def __init__(self, message: str = "File download timed out"):
+        super().__init__(message, 408)
+
+
+class FileSizeError(DeepfakeDetectionError):
+    """Exception raised when file size exceeds limit."""
+    
+    def __init__(self, message: str = "File size exceeds maximum allowed size"):
+        super().__init__(message, 400)
+
+
+class DetectorError(DeepfakeDetectionError):
+    """Exception raised when detector model fails."""
+    
+    def __init__(self, message: str = "Deepfake detection failed"):
+        super().__init__(message, 500)
+
+
+class UnsupportedModelError(DeepfakeDetectionError):
+    """Exception raised when requested model is not supported."""
+    
+    def __init__(self, model_name: str):
+        message = f"Detector model '{model_name}' is not supported"
+        super().__init__(message, 400)

backend/main.py

@@ -0,0 +1,5 @@
+import uvicorn
+from app import app
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="127.0.0.1", port=8000)

backend/requirements.txt

@@ -0,0 +1,6 @@
+fastapi==0.115.0
+uvicorn[standard]==0.30.0
+httpx==0.27.0
+pydantic==2.8.2
+pydantic-settings==2.3.1
+python-multipart==0.0.6

backend/setup.py

@@ -0,0 +1,68 @@
+import os
+import sys
+import subprocess
+
+
+def run_command(command, description):
+    """Run a command and handle errors."""
+    print(f"\n{'='*60}")
+    print(f"📍 {description}")
+    print(f"{'='*60}")
+    try:
+        result = subprocess.run(command, shell=True, check=True)
+        return result.returncode == 0
+    except subprocess.CalledProcessError as e:
+        print(f"❌ Error: {description} failed")
+        return False
+
+
+def main():
+    """Setup the development environment."""
+    print("\n" + "="*60)
+    print("🚀 Deepfake Detection Service - Backend Setup")
+    print("="*60)
+    print(f"✅ Python version: {sys.version}")
+    
+    # Determine OS for venv activation
+    is_windows = sys.platform == "win32"
+    venv_path = "venv"
+    
+    # Create virtual environment
+    if not run_command(
+        f"{sys.executable} -m venv {venv_path}",
+        "Creating virtual environment"
+    ):
+        sys.exit(1)
+    
+    # Activate venv and install dependencies
+    if is_windows:
+        activate_cmd = f"{venv_path}\\Scripts\\activate && pip install -r requirements.txt"
+    else:
+        activate_cmd = f"source {venv_path}/bin/activate && pip install -r requirements.txt"
+    
+    if not run_command(activate_cmd, "Installing dependencies"):
+        sys.exit(1)
+    
+    # Create .env file if it doesn't exist
+    if not os.path.exists(".env"):
+        run_command("copy .env.example .env" if is_windows else "cp .env.example .env",
+                   "Creating .env file from template")
+    
+    print("\n" + "="*60)
+    print("✅ Setup completed successfully!")
+    print("="*60)
+    print("\n📝 Next steps:")
+    print(f"  1. Activate virtual environment:")
+    if is_windows:
+        print(f"     {venv_path}\\Scripts\\activate")
+    else:
+        print(f"     source {venv_path}/bin/activate")
+    print(f"\n  2. Start the server:")
+    print(f"     python main.py")
+    print(f"\n  3. Visit http://127.0.0.1:8000/docs for interactive API docs")
+    print(f"\n  4. Check .env file for configuration options")
+    print("\n" + "="*60)
+
+
+if __name__ == "__main__":
+    main()