.

backend/DETECTOR_TEMPLATE.py

@@ -1,105 +0,0 @@
-"""
-Template for creating new detector models.
-
-Copy this file and implement the detect() method with your custom ML logic.
-Then register it in app/services/detector/__init__.py
-
-Example:
-    # Copy this file as app/services/detector/mydetector.py
-    # Modify the class and model_name
-    # Add to get_detector() in __init__.py
-"""
-
-import logging
-import time
-from typing import Dict, Any
-
-from app.services.detector.base import BaseDetector
-
-logger = logging.getLogger(__name__)
-
-
-class MyDetector(BaseDetector):
-    """
-    Template detector implementation.
-    
-    Replace 'MyDetector' with your detector name.
-    """
-    
-    def __init__(self):
-        """Initialize the detector."""
-        # Change 'mydetector' to your model name
-        super().__init__("mydetector")
-    
-    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 with:
-            - is_deepfake: Boolean
-            - confidence: Float between 0.0 and 1.0
-            - analysis_time: Float in seconds
-        """
-        logger.info(f"Starting detection with {self.model_name}...")
-        
-        start_time = time.time()
-        
-        # ========================================
-        # TODO: Implement your ML model logic here
-        # ========================================
-        # Example:
-        # 1. Preprocess file_bytes if needed
-        # 2. Load your ML model
-        # 3. Run inference
-        # 4. Post-process results
-        
-        # For now, return placeholder results
-        is_deepfake = True
-        confidence = 0.85
-        
-        analysis_time = time.time() - start_time
-        
-        result = {
-            "is_deepfake": is_deepfake,
-            "confidence": round(confidence, 3),
-            "analysis_time": round(analysis_time, 3),
-        }
-        
-        logger.info(f"Detection completed. Result: {result}")
-        return result
-
-
-# =====================================================
-# REGISTRATION INSTRUCTIONS:
-# =====================================================
-# 
-# 1. Save this file as: app/services/detector/mydetector.py
-# 
-# 2. Update app/services/detector/__init__.py:
-#    
-#    from app.services.detector.mydetector import MyDetector
-#    
-#    def get_detector(model_name: str = "mock") -> BaseDetector:
-#        detectors = {
-#            "mock": MockDetector,
-#            "mydetector": MyDetector,  # ADD THIS LINE
-#        }
-#        # ... rest of function
-# 
-# 3. Update .env.example:
-#    
-#    DEFAULT_DETECTOR_MODEL=mydetector
-# 
-# 4. Test your detector:
-#    
-#    POST /analyze
-#    {
-#        "file_url": "https://example.com/video.mp4",
-#        "model": "mydetector"
-#    }
-#
-# =====================================================

backend/DEVELOPMENT.md

@@ -1,351 +0,0 @@
-# Development Guide for Deepfake Detection Backend
-
-## Project Overview
-
-This is a production-ready FastAPI backend for deepfake detection with a modular, extensible architecture. It's designed to support multiple ML models and easy integration with task queues like Redis.
-
-## Architecture Overview
-
-```
-FastAPI Application (app/__init__.py)
-├── API Routes (app/api/routes.py)
-│   ├── GET / (Health check)
-│   └── POST /analyze (Main endpoint)
-├── Services Layer (app/services/)
-│   ├── download.py (File downloading)
-│   ├── queue.py (Redis-ready task queue)
-│   └── detector/ (ML model implementations)
-│       ├── base.py (Abstract interface)
-│       ├── mock.py (Test implementation)
-│       └── [custom_detector].py (Add your models here)
-├── Models/Schemas (app/models/schemas.py)
-└── Core Configuration (app/core/)
-    ├── config.py (Settings)
-    └── logging_config.py (Logging setup)
-```
-
-## Adding a New ML Model
-
-### Step 1: Create Your Detector Class
-
-Create a new file in `app/services/detector/` (e.g., `deepseek.py`):
-
-```python
-import logging
-import time
-from typing import Dict, Any
-from app.services.detector.base import BaseDetector
-
-logger = logging.getLogger(__name__)
-
-class DeepseekDetector(BaseDetector):
-    def __init__(self):
-        super().__init__("deepseek")
-        # Initialize your model here
-        # self.model = load_deepseek_model()
-    
-    async def detect(self, file_bytes: bytes) -> Dict[str, Any]:
-        logger.info("Starting Deepseek detection...")
-        start_time = time.time()
-        
-        # Your detection logic
-        is_deepfake = False  # Your ML logic
-        confidence = 0.95
-        
-        analysis_time = time.time() - start_time
-        
-        return {
-            "is_deepfake": is_deepfake,
-            "confidence": round(confidence, 3),
-            "analysis_time": round(analysis_time, 3),
-        }
-```
-
-### Step 2: Register the Detector
-
-Update `app/services/detector/__init__.py`:
-
-```python
-from app.services.detector.deepseek import DeepseekDetector
-
-def get_detector(model_name: str = "mock") -> BaseDetector:
-    detectors = {
-        "mock": MockDetector,
-        "deepseek": DeepseekDetector,  # Add this
-    }
-    # ... rest of code
-```
-
-### Step 3: Update Configuration
-
-Add to `.env`:
-```
-DEFAULT_DETECTOR_MODEL=deepseek
-```
-
-### Step 4: Test Your Model
-
-```bash
-curl -X POST http://localhost:8000/analyze \
-  -H "Content-Type: application/json" \
-  -d '{"file_url": "https://example.com/video.mp4", "model": "deepseek"}'
-```
-
-## Adding Redis Task Queuing
-
-### Step 1: Install Redis
-
-```bash
-pip install redis aioredis
-```
-
-### Step 2: Update requirements.txt
-
-Add to `requirements.txt`:
-```
-redis==5.0.0
-aioredis==2.0.1
-```
-
-### Step 3: Enable Redis
-
-In `.env`:
-```
-REDIS_ENABLED=True
-REDIS_URL=redis://localhost:6379
-```
-
-### Step 4: Implement Queue Service
-
-Update `app/services/queue.py` to implement async Redis operations:
-
-```python
-import aioredis
-import json
-
-class QueueService:
-    async def _initialize_redis(self):
-        self.redis_client = await aioredis.create_redis_pool(
-            self.settings.REDIS_URL
-        )
-    
-    async def enqueue_analysis(self, file_url: str, model: str, task_id: str):
-        task_data = {
-            "task_id": task_id,
-            "file_url": file_url,
-            "model": model,
-        }
-        await self.redis_client.lpush(
-            self.settings.REDIS_QUEUE_NAME,
-            json.dumps(task_data)
-        )
-    
-    async def get_task_result(self, task_id: str):
-        result = await self.redis_client.get(f"result:{task_id}")
-        return json.loads(result) if result else None
-```
-
-### Step 5: Create Worker
-
-Create `worker.py` in the backend directory:
-
-```python
-import asyncio
-import json
-import aioredis
-from app.services.detector import get_detector
-from app.services.download import download_file
-
-async def worker():
-    redis = await aioredis.create_redis_pool("redis://localhost:6379")
-    
-    while True:
-        task_json = await redis.rpop("deepfake_analysis")
-        if not task_json:
-            await asyncio.sleep(1)
-            continue
-        
-        task = json.loads(task_json)
-        try:
-            file_bytes = await download_file(task["file_url"])
-            detector = get_detector(task["model"])
-            result = await detector.detect(file_bytes)
-            
-            await redis.set(
-                f"result:{task['task_id']}",
-                json.dumps(result)
-            )
-        except Exception as e:
-            logger.error(f"Task failed: {e}")
-        
-        await asyncio.sleep(0.1)
-
-if __name__ == "__main__":
-    asyncio.run(worker())
-```
-
-## Configuration Options
-
-See `.env.example` for all available settings:
-
-- `HOST`, `PORT` - Server address
-- `DOWNLOAD_TIMEOUT` - File download timeout in seconds
-- `MAX_FILE_SIZE` - Maximum file size in bytes
-- `DEFAULT_DETECTOR_MODEL` - Default ML model to use
-- `REDIS_ENABLED` - Enable Redis queuing
-- `LOG_LEVEL` - Logging verbosity (DEBUG, INFO, WARNING, ERROR)
-
-## API Response Format
-
-All responses follow a consistent format:
-
-**Success (200):**
-```json
-{
-  "is_deepfake": boolean,
-  "confidence": float,
-  "analysis_time": float,
-  "model_used": "model_name"
-}
-```
-
-**Error (4xx/5xx):**
-```json
-{
-  "error": "Error message",
-  "status_code": 400,
-  "details": "Optional additional details"
-}
-```
-
-## Error Handling
-
-The service handles:
-- **400 Bad Request**: Invalid URL, file too large, unsupported model
-- **408 Request Timeout**: Download timeout
-- **500 Internal Server Error**: Detector failure or unexpected error
-
-Custom exceptions in `app/utils/exceptions.py` provide specific error types for proper handling.
-
-## Logging
-
-All operations are logged with timestamps and levels:
-
-```python
-logger.info("User action")        # Normal operations
-logger.warning("Something odd")   # Unexpected but handled
-logger.error("Failed action")     # Error occurred
-logger.debug("Detailed info")     # Debug information (if enabled)
-```
-
-Enable debug logging:
-```
-LOG_LEVEL=DEBUG python main.py
-```
-
-## Testing
-
-### Unit Test Example
-
-```python
-# tests/test_detector.py
-import pytest
-from app.services.detector import get_detector
-
-@pytest.mark.asyncio
-async def test_mock_detector():
-    detector = get_detector("mock")
-    result = await detector.detect(b"test_data")
-    
-    assert "is_deepfake" in result
-    assert 0.0 <= result["confidence"] <= 1.0
-    assert result["analysis_time"] > 0
-```
-
-### Integration Test Example
-
-```python
-# tests/test_api.py
-from fastapi.testclient import TestClient
-from app import create_app
-
-client = TestClient(create_app())
-
-def test_health():
-    response = client.get("/")
-    assert response.status_code == 200
-    assert response.json()["status"] == "ok"
-
-@pytest.mark.asyncio
-async def test_analyze():
-    response = await client.post(
-        "/analyze",
-        json={"file_url": "https://example.com/file.mp4"}
-    )
-    assert response.status_code == 200
-```
-
-## Performance Considerations
-
-1. **Async Operations**: All I/O is non-blocking using async/await
-2. **Connection Pooling**: httpx uses connection pooling for downloads
-3. **Memory Management**: Files are kept in memory (configure MAX_FILE_SIZE)
-4. **Timeouts**: All operations have configurable timeouts
-5. **Logging Overhead**: Disable debug logging in production
-
-## Security Considerations
-
-- Validate all URLs with Pydantic's HttpUrl validator
-- Limit file size to prevent DoS attacks
-- Add rate limiting for production use (FastAPI-limiter)
-- Sanitize error messages to avoid information leakage
-- Use HTTPS in production
-- Add API authentication/authorization
-
-## Deployment
-
-For production deployment:
-
-1. Use a production ASGI server (Gunicorn + Uvicorn)
-2. Set `DEBUG=False` in `.env`
-3. Configure logging to file
-4. Enable Redis for scalability
-5. Use environment secrets management
-6. Add reverse proxy (nginx/Apache)
-7. Enable CORS if needed
-8. Add health checks for monitoring
-
-## Common Issues and Solutions
-
-**Issue**: Port 8000 already in use
-```bash
-PORT=8001 python main.py
-```
-
-**Issue**: Module import errors
-```bash
-# Make sure you're in backend directory and venv is activated
-cd backend
-source venv/bin/activate  # or venv\Scripts\activate on Windows
-```
-
-**Issue**: File download fails
-- Check URL is accessible
-- Increase DOWNLOAD_TIMEOUT
-- Check MAX_FILE_SIZE limit
-
-**Issue**: Detector not found
-- Check model name spelling
-- Verify registration in `get_detector()`
-- List available models: `GET /`
-
-## Additional Resources
-
-- [FastAPI Documentation](https://fastapi.tiangolo.com/)
-- [Pydantic Validation](https://docs.pydantic.dev/)
-- [Uvicorn Configuration](https://www.uvicorn.org/)
-- [Python asyncio](https://docs.python.org/3/library/asyncio.html)
-
----
-
-For more help, refer to README.md or the inline code documentation.

backend/DISCORD_BOT_EXAMPLE.py

@@ -1,277 +0,0 @@
-"""
-Example: Integrating the Deepfake Detection Backend with Discord Bot
-
-This example shows how to call the backend API from a Discord bot.
-"""
-
-import discord
-from discord.ext import commands
-import httpx
-import asyncio
-from typing import Optional
-
-# Backend configuration
-BACKEND_URL = "http://127.0.0.1:8000"
-BACKEND_TIMEOUT = 60  # seconds
-
-
-class DeepfakeDetector(commands.Cog):
-    """Discord bot cog for deepfake detection."""
-    
-    def __init__(self, bot: commands.Bot):
-        self.bot = bot
-        self.backend_url = BACKEND_URL
-        self.http_client = None
-    
-    @commands.Cog.listener()
-    async def on_ready(self):
-        """Initialize HTTP client when bot is ready."""
-        if self.http_client is None:
-            self.http_client = httpx.AsyncClient(timeout=BACKEND_TIMEOUT)
-        print(f"Deepfake detector loaded - Backend: {self.backend_url}")
-    
-    async def analyze_url(self, file_url: str, model: str = "mock") -> Optional[dict]:
-        """
-        Send a file URL to the backend for deepfake analysis.
-        
-        Args:
-            file_url: URL of the file to analyze
-            model: Model to use for detection
-            
-        Returns:
-            Analysis result or None if failed
-        """
-        try:
-            if self.http_client is None:
-                self.http_client = httpx.AsyncClient(timeout=BACKEND_TIMEOUT)
-            
-            response = await self.http_client.post(
-                f"{self.backend_url}/analyze",
-                json={"file_url": file_url, "model": model},
-            )
-            
-            if response.status_code == 200:
-                return response.json()
-            else:
-                print(f"Backend error: {response.status_code} - {response.text}")
-                return None
-        except Exception as e:
-            print(f"Failed to analyze: {e}")
-            return None
-    
-    @commands.command(name="deepfake_check")
-    async def deepfake_check(self, ctx: commands.Context, url: str):
-        """
-        Check if a file at the given URL is a deepfake.
-        
-        Usage:
-            !deepfake_check https://example.com/video.mp4
-        """
-        # Validate URL format
-        if not url.startswith(("http://", "https://")):
-            await ctx.send("❌ Invalid URL. Please provide a valid HTTP(S) URL.")
-            return
-        
-        # Show loading message
-        async with ctx.typing():
-            # Check if backend is running
-            try:
-                health_response = await self.http_client.get(f"{self.backend_url}/")
-                if health_response.status_code != 200:
-                    await ctx.send("❌ Backend service is not responding. Please try again later.")
-                    return
-            except Exception as e:
-                await ctx.send(f"❌ Cannot connect to backend service: {e}")
-                return
-            
-            # Analyze the file
-            await ctx.send(f"🔍 Analyzing file from: {url}\nThis may take a moment...")
-            
-            result = await self.analyze_url(url)
-            
-            if result is None:
-                await ctx.send("❌ Analysis failed. Please check the URL and try again.")
-                return
-        
-        # Format and display results
-        is_deepfake = result["is_deepfake"]
-        confidence = result["confidence"]
-        analysis_time = result["analysis_time"]
-        model_used = result.get("model_used", "unknown")
-        
-        # Create embed for nice formatting
-        embed = discord.Embed(
-            title="🔬 Deepfake Detection Result",
-            color=discord.Color.red() if is_deepfake else discord.Color.green(),
-        )
-        
-        embed.add_field(
-            name="Detection Result",
-            value="⚠️ **DEEPFAKE DETECTED**" if is_deepfake else "✅ **AUTHENTIC**",
-            inline=False,
-        )
-        
-        embed.add_field(
-            name="Confidence",
-            value=f"{confidence:.1%}",
-            inline=True,
-        )
-        
-        embed.add_field(
-            name="Analysis Time",
-            value=f"{analysis_time:.2f}s",
-            inline=True,
-        )
-        
-        embed.add_field(
-            name="Model Used",
-            value=model_used,
-            inline=True,
-        )
-        
-        embed.set_footer(text="Analysis performed by Deepfake Detection Service")
-        
-        await ctx.send(embed=embed)
-    
-    @commands.command(name="backend_status")
-    async def backend_status(self, ctx: commands.Context):
-        """Check the status of the deepfake detection backend."""
-        try:
-            async with ctx.typing():
-                response = await self.http_client.get(f"{self.backend_url}/")
-                
-                if response.status_code == 200:
-                    data = response.json()
-                    embed = discord.Embed(
-                        title="🟢 Backend Status",
-                        color=discord.Color.green(),
-                    )
-                    embed.add_field(
-                        name="Service",
-                        value=data["service"],
-                        inline=True,
-                    )
-                    embed.add_field(
-                        name="Version",
-                        value=data["version"],
-                        inline=True,
-                    )
-                    embed.add_field(
-                        name="Available Models",
-                        value=", ".join(data["available_models"]),
-                        inline=False,
-                    )
-                    await ctx.send(embed=embed)
-                else:
-                    await ctx.send("❌ Backend is not responding properly.")
-        except Exception as e:
-            await ctx.send(f"❌ Cannot connect to backend: {e}")
-    
-    async def cog_unload(self):
-        """Cleanup when cog is unloaded."""
-        if self.http_client:
-            await self.http_client.aclose()
-
-
-# Setup function to add this cog to your bot
-async def setup(bot: commands.Bot):
-    """Add the deepfake detector cog to the bot."""
-    await bot.add_cog(DeepfakeDetector(bot))
-
-
-# ============================================================================
-# EXAMPLE BOT IMPLEMENTATION
-# ============================================================================
-
-# If you want to use this as a standalone bot, here's how:
-
-# bot = commands.Bot(command_prefix="!", intents=discord.Intents.default())
-
-# @bot.event
-# async def on_ready():
-#     print(f"Bot logged in as {bot.user}")
-
-# async def main():
-#     async with bot:
-#         await setup(bot)
-#         await bot.start("YOUR_BOT_TOKEN")
-
-# if __name__ == "__main__":
-#     asyncio.run(main())
-
-# ============================================================================
-# USAGE IN YOUR BOT
-# ============================================================================
-
-# 1. Save this file as: discord_bot_example.py or similar
-# 
-# 2. In your main bot file, add:
-#    
-#    from discord_bot_example import setup
-#    
-#    async def main():
-#        async with bot:
-#            await setup(bot)  # Load the deepfake detector cog
-#            await bot.start(TOKEN)
-#
-# 3. Start the backend server:
-#    cd backend
-#    python main.py
-#
-# 4. Run your Discord bot
-#
-# 5. In Discord, use the commands:
-#    !deepfake_check https://example.com/video.mp4
-#    !backend_status
-
-# ============================================================================
-# COMMAND EXAMPLES
-# ============================================================================
-
-# !deepfake_check https://example.com/suspicious_video.mp4
-#   Analyzes the video at the given URL for deepfake content
-#
-# !backend_status
-#   Shows the current status and available models of the backend
-
-# ============================================================================
-# API RESPONSE HANDLING
-# ============================================================================
-
-# The backend returns responses like:
-# {
-#   "is_deepfake": true,
-#   "confidence": 0.847,
-#   "analysis_time": 1.234,
-#   "model_used": "mock"
-# }
-#
-# Error responses:
-# {
-#   "error": "Invalid URL format",
-#   "status_code": 400,
-#   "details": null
-# }
-
-# ============================================================================
-# CUSTOMIZATION OPTIONS
-# ============================================================================
-
-# 1. Change model selection:
-#    await detector.analyze_url(url, model="deepseek")
-#
-# 2. Add custom formatting:
-#    - Modify the embed creation in deepfake_check()
-#    - Add database logging of results
-#    - Notify admins of detected deepfakes
-#
-# 3. Add rate limiting:
-#    - Use discord.ext.commands.cooldown decorator
-#    - Implement per-user/channel limits
-#
-# 4. Add file upload support:
-#    - Check message attachments
-#    - Upload to temporary storage
-#    - Generate URL for backend analysis
-
-print("Discord Bot Deepfake Detector Example - Ready to integrate!")