startuping cleanup

QUICKSTART.md

@@ -16,14 +16,17 @@ 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      # Windows
-# OR
-./run.sh     # macOS/Linux
+run.bat
 ```
 
 ## 📡 API Quick Test
@@ -44,144 +47,3 @@ curl -X POST http://localhost:8000/analyze \
 - **Swagger UI**: http://localhost:8000/docs
 - **ReDoc**: http://localhost:8000/redoc
 
-## 🔧 Configuration
-
-Edit `backend/.env`:
-```env
-HOST=127.0.0.1
-PORT=8000
-DEFAULT_DETECTOR_MODEL=mock
-LOG_LEVEL=INFO
-DOWNLOAD_TIMEOUT=30
-MAX_FILE_SIZE=104857600
-```
-
-## 📦 Project Structure
-
-```
-backend/
-├── app/
-│   ├── api/         # Routes
-│   ├── services/    # Business logic (download, ML models, queuing)
-│   ├── models/      # Data schemas
-│   ├── core/        # Configuration
-│   └── utils/       # Exceptions
-├── main.py          # Entry point
-├── README.md        # Full API docs
-└── DEVELOPMENT.md   # Adding models, Redis, etc.
-```
-
-## ➕ Adding a New ML Model
-
-1. Copy `DETECTOR_TEMPLATE.py`
-2. Implement the `detect()` method
-3. Register in `app/services/detector/__init__.py`
-4. Update `.env` if setting as default
-
-See `DEVELOPMENT.md` for detailed steps.
-
-## 🔗 Integrating with Discord Bot
-
-Use `DISCORD_BOT_EXAMPLE.py` as a template:
-
-```python
-from discord_bot_example import setup
-
-# In your bot startup:
-await setup(bot)
-
-# Then use in your bot:
-# !deepfake_check https://example.com/video.mp4
-# !backend_status
-```
-
-## 🐛 Common Issues
-
-| Problem | Solution |
-|---------|----------|
-| `ModuleNotFoundError` | Activate venv first |
-| Port 8000 in use | Change port: `PORT=8001 python main.py` |
-| Import errors | `pip install -r requirements.txt` |
-| Download timeout | Increase: `DOWNLOAD_TIMEOUT=60 python main.py` |
-
-## 📊 Supported File Types
-
-Any file type via URL:
-- Videos: `.mp4`, `.webm`, `.avi`, etc.
-- Images: `.jpg`, `.png`, `.gif`, etc.
-- Any file up to 100 MB (configurable)
-
-## 🔄 Async Support
-
-Backend is fully async:
-- Non-blocking file downloads
-- Concurrent requests supported
-- Scalable to Redis task queuing
-
-## 📝 Logging Levels
-
-```bash
-# Normal operation
-LOG_LEVEL=INFO python main.py
-
-# Verbose debugging
-LOG_LEVEL=DEBUG python main.py
-
-# Warnings and errors only
-LOG_LEVEL=WARNING python main.py
-```
-
-## 🚀 Production Deployment
-
-For production, use Gunicorn with Uvicorn:
-
-```bash
-pip install gunicorn
-gunicorn main:app -w 4 -k uvicorn.workers.UvicornWorker --bind 0.0.0.0:8000
-```
-
-## 📞 Response Format
-
-**Success:**
-```json
-{
-  "is_deepfake": true,
-  "confidence": 0.95,
-  "analysis_time": 1.5,
-  "model_used": "mock"
-}
-```
-
-**Error:**
-```json
-{
-  "error": "Invalid URL format",
-  "status_code": 400,
-  "details": null
-}
-```
-
-## 🔐 Default Security Settings
-
-- Max file size: 100 MB
-- Download timeout: 30 seconds
-- URL validation: Enabled
-- Error details: Minimal (no leakage)
-
-Increase security for production:
-- Add API keys/authentication
-- Implement rate limiting
-- Use HTTPS
-- Add CORS restrictions
-
-## 🎯 Next Steps
-
-1. ✅ Backend running?
-2. ⏳ Test with sample URLs
-3. ⏳ Create Discord bot using example
-4. ⏳ Add your ML models
-5. ⏳ Deploy to production
-
----
-
-For complete documentation, see `README.md` and `DEVELOPMENT.md` in the backend folder.

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

@@ -4,6 +4,7 @@
 APP_NAME=Deepfake Detection Service
 APP_VERSION=1.0.0
 DEBUG=True
+RELOAD=True
 
 # Server Configuration
 HOST=127.0.0.1

backend/README.md

@@ -1,35 +1,5 @@
 # Deepfake Detection Service Backend
 
-A scalable FastAPI backend for deepfake detection with support for multiple ML models and future Redis integration for task queuing.
-
-## 📁 Project Structure
-
-```
-backend/
-├── app/
-│   ├── core/                 # Core configuration and setup
-│   │   ├── config.py        # Settings management
-│   │   └── logging_config.py # Logging setup
-│   ├── models/              # Data models
-│   │   └── schemas.py       # Pydantic request/response models
-│   ├── services/            # Business logic layer
-│   │   ├── download.py      # File download service
-│   │   ├── queue.py         # Task queue service (Redis-ready)
-│   │   └── detector/        # ML detector models
-│   │       ├── base.py      # Abstract base detector class
-│   │       └── mock.py      # Mock detector implementation
-│   ├── api/                 # API endpoints
-│   │   └── routes.py        # Route handlers
-│   └── utils/               # Utilities
-│       └── exceptions.py    # Custom exceptions
-├── main.py                  # Application entry point
-├── requirements.txt         # Python dependencies
-├── .env.example            # Example environment variables
-└── README.md               # This file
-```
-
-## 🚀 Quick Start
-
 ### Prerequisites
 - Python 3.8+
 - pip or conda
@@ -120,100 +90,6 @@ Content-Type: application/json
 - `408 Request Timeout`: File download timed out
 - `500 Internal Server Error`: Server error during analysis
 
-## ⚙️ Configuration
-
-Configuration is managed through environment variables. Create a `.env` file in the `backend/` directory:
-
-```bash
-cp .env.example .env
-```
-
-Edit `.env` with your settings:
-
-```env
-# Server
-HOST=127.0.0.1
-PORT=8000
-
-# File handling
-DOWNLOAD_TIMEOUT=30
-MAX_FILE_SIZE=104857600  # 100 MB
-
-# ML Model
-DEFAULT_DETECTOR_MODEL=mock
-
-# Redis (for future use)
-REDIS_ENABLED=False
-REDIS_URL=redis://localhost:6379
-
-# Logging
-LOG_LEVEL=INFO
-LOG_FILE=
-```
-
-## 🎯 Adding New ML Models
-
-The architecture supports easy addition of new detector models:
-
-1. **Create a new detector class** in `app/services/detector/`:
-
-```python
-# app/services/detector/deepseek.py
-from app.services.detector.base import BaseDetector
-
-class DeepseekDetector(BaseDetector):
-    def __init__(self):
-        super().__init__("deepseek")
-    
-    async def detect(self, file_bytes: bytes) -> dict:
-        # Your ML model implementation
-        return {
-            "is_deepfake": False,
-            "confidence": 0.95,
-            "analysis_time": 2.5
-        }
-```
-
-2. **Register the detector** in `app/services/detector/__init__.py`:
-
-```python
-def get_detector(model_name: str = "mock") -> BaseDetector:
-    detectors = {
-        "mock": MockDetector,
-        "deepseek": DeepseekDetector,  # Add this
-        # ... more models
-    }
-    # ... rest of code
-```
-
-3. **Update `.env.example`** to document the new model
-
-## 🚦 Future Redis Integration
-
-The queue service is designed to support Redis task queuing without major refactoring:
-
-1. Set `REDIS_ENABLED=True` in `.env`
-2. Set correct `REDIS_URL`
-3. The queue service will automatically use Redis for task management
-
-Redis support will enable:
-- Asynchronous task processing
-- Task result caching
-- Improved scalability for high-volume requests
-
-## 📝 Logging
-
-Logs are configured in `app/core/logging_config.py`. By default:
-- Level: INFO
-- Output: Console
-- Rotation: Automatic (if LOG_FILE is set)
-
-Configure logging level via environment:
-```bash
-LOG_LEVEL=DEBUG  # For verbose logging
-```
-
-## 🧪 Testing the API
 
 ### Using curl:
 ```bash
@@ -222,34 +98,6 @@ curl -X POST http://localhost:8000/analyze \
   -d '{"file_url": "https://example.com/video.mp4"}'
 ```
 
-### Using Python requests:
-```python
-import requests
-
-response = requests.post(
-    "http://localhost:8000/analyze",
-    json={"file_url": "https://example.com/video.mp4"}
-)
-print(response.json())
-```
-
-### Using httpx (async):
-```python
-import httpx
-import asyncio
-
-async def test():
-    async with httpx.AsyncClient() as client:
-        response = await client.post(
-            "http://localhost:8000/analyze",
-            json={"file_url": "https://example.com/video.mp4"}
-        )
-        print(response.json())
-
-asyncio.run(test())
-```
-
-## 🔒 Error Handling
 
 The API provides comprehensive error handling:
 
@@ -283,50 +131,3 @@ The API provides comprehensive error handling:
 }
 ```
 
-## 🔧 Troubleshooting
-
-**Port already in use:**
-```bash
-# Change port via environment variable
-PORT=8001 python main.py
-```
-
-**Import errors:**
-```bash
-# Ensure you're in the backend directory and have activated venv
-cd backend
-source venv/bin/activate  # or venv\Scripts\activate on Windows
-pip install -r requirements.txt
-```
-
-**Timeout issues:**
-```bash
-# Increase timeout for slow downloads
-DOWNLOAD_TIMEOUT=60 python main.py
-```
-
-## 📦 Dependencies
-
-- **FastAPI**: Modern async web framework
-- **Uvicorn**: ASGI server
-- **Pydantic**: Data validation and settings
-- **httpx**: Async HTTP client for file downloads
-
-See `requirements.txt` for exact versions.
-
-## 📄 License
-
-This project is part of the DiscordBot backend service.
-
-## 🤝 Contributing
-
-To add new features or models:
-
-1. Follow the existing code structure
-2. Implement abstract base classes for new functionality
-3. Add comprehensive logging
-4. Update documentation and examples
-
-## 📧 Support
-
-For issues or questions, please refer to the project documentation or contact the development team.

backend/app/__init__.py

@@ -1,36 +1,13 @@
-"""Deepfake Detection Service Application"""
-
 from fastapi import FastAPI
 from app.api.routes import router as api_router
 from app.core.logging_config import setup_logging
-from app.core.config import Settings
 
-__version__ = Settings.APP_VERSION or "1.0.0"
+setup_logging()
 
+app = FastAPI(
+    title="Deepfake Detection Service",
+    description="Backend service for deepfake detection with support for multiple ML models",
+    version="1.0.0",
+)
 
-def create_app() -> FastAPI:
-    """Create and configure the FastAPI application."""
-    setup_logging()
-    
-    app = FastAPI(
-        title="Deepfake Detection Service",
-        description="Backend service for deepfake detection with support for multiple ML models",
-        version=__version__,
-    )
-    
-    # Include API routes
-    app.include_router(api_router)
-    
-    @app.on_event("startup")
-    async def startup_event():
-        import logging
-        logger = logging.getLogger(__name__)
-        logger.info("Deepfake Detection Service is starting up...")
-    
-    @app.on_event("shutdown")
-    async def shutdown_event():
-        import logging
-        logger = logging.getLogger(__name__)
-        logger.info("Deepfake Detection Service is shutting down...")
-    
-    return app
+app.include_router(api_router)

backend/app/api/routes.py

@@ -77,6 +77,7 @@ async def analyze(request: AnalysisRequest) -> AnalysisResponse:
         f"using model: {detector_model}"
     )
     
+    
     try:
         try:
             detector = get_detector(detector_model)

backend/main.py

@@ -1,35 +1,5 @@
-"""
-Deepfake Detection Service - Backend Entry Point
-
-This is the main entry point for the FastAPI application.
-Run this file directly to start the server on localhost:8000
-"""
-
-import logging
-from app import create_app
-from app.core.config import get_settings
-
-logger = logging.getLogger(__name__)
-
-
-def main():
-    """Initialize and run the FastAPI application."""
-    settings = get_settings()
-    app = create_app()
-    
-    import uvicorn
-    
-    logger.info(
-        f"Starting {settings.APP_NAME} on {settings.HOST}:{settings.PORT}"
-    )
-    
-    uvicorn.run(
-        app,
-        host=settings.HOST,
-        port=settings.PORT,
-        log_level=settings.LOG_LEVEL.lower(),
-    )
-
+import uvicorn
+from app import app
 
 if __name__ == "__main__":
-    main()
+    uvicorn.run(app, host="127.0.0.1", port=8000)

backend/run.bat

@@ -1,6 +0,0 @@
-@echo off
-REM Deepfake Detection Service - Windows Run Script
-
-echo Starting Deepfake Detection Service Backend...
-python main.py
-pause

backend/setup.py

@@ -1,10 +1,3 @@
-#!/usr/bin/env python
-"""
-Setup script for the Deepfake Detection Service backend.
-
-Run: python setup.py
-"""
-
 import os
 import sys
 import subprocess
@@ -28,12 +21,6 @@ def main():
     print("\n" + "="*60)
     print("🚀 Deepfake Detection Service - Backend Setup")
     print("="*60)
-    
-    # Check Python version
-    if sys.version_info < (3, 8):
-        print("❌ Python 3.8 or higher is required")
-        sys.exit(1)
-    
     print(f"✅ Python version: {sys.version}")
     
     # Determine OS for venv activation