Initial project upload via Python API for Flask Space

.gitattributes

@@ -33,3 +33,12 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+demo/demo.mp4 filter=lfs diff=lfs merge=lfs -text
+demo/demo2.png filter=lfs diff=lfs merge=lfs -text
+demo/demo4.png filter=lfs diff=lfs merge=lfs -text
+demo/demo5.png filter=lfs diff=lfs merge=lfs -text
+static/uploads/28afe2d042a341ceb60c187954deccfc.jpg filter=lfs diff=lfs merge=lfs -text
+static/uploads/8faf0f3a7992493d9870225198e49273.jpg filter=lfs diff=lfs merge=lfs -text
+static/uploads/a326c59eb34f48ab939624dcac5bd556.jpg filter=lfs diff=lfs merge=lfs -text
+static/uploads/d9ab337c2ef44bc5ac7b2d2a8b136b19.jpg filter=lfs diff=lfs merge=lfs -text
+static/uploads/e3e074e58f9545b294ec541566759e45.jpg filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,19 @@
+# 1. Use a base Python image
+FROM python:3.10-slim
+
+# 2. Set the working directory inside the container
+WORKDIR /app
+
+# 3. Copy the dependencies file and install them
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# 4. Copy the rest of your application code
+COPY . .
+
+# 5. Expose the required port (Hugging Face default)
+EXPOSE 7860
+
+# 6. Start the production server (Gunicorn is highly recommended for production)
+# The format is: gunicorn -b <host>:<port> <app_file>:<flask_app_object>
+CMD ["gunicorn", "-b", "0.0.0.0:7860", "app:app"]

LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Eslam Tarek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,11 +1,355 @@
 ---
 title: FactSight
-emoji: 👁
-colorFrom: gray
-colorTo: green
-sdk: docker
-pinned: false
-license: mit
+emoji: 🚀
+colorFrom: blue
+colorTo: purple
+sdk: docker 
+# Optional: You can specify the port if it's not the default 7860
+# app_port: 7860 
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+# FactSight: Advanced Fake News Detection System
+
+[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
+[![Flask](https://img.shields.io/badge/flask-3.1.1-green.svg)](https://flask.palletsprojects.com/)
+[![PyTorch](https://img.shields.io/badge/pytorch-2.8.0-red.svg)](https://pytorch.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## 📋 Table of Contents
+
+- [Overview](#overview)
+- [Architecture](#architecture)
+- [Installation](#installation)
+- [Usage](#usage)
+- [Services & Models Deep Dive](#services--models-deep-dive)
+  - [Text Analysis Services](#text-analysis-services)
+  - [Image Analysis Services](#image-analysis-services)
+  - [Fact-Checking Integration](#fact-checking-integration)
+- [Model Performance](#model-performance)
+- [Demo Media Files](#demo-media-files)
+- [Configuration](#configuration)
+- [API Endpoints](#api-endpoints)
+- [Contributing](#contributing)
+- [License](#license)
+
+## 🎯 Overview
+
+**FactSight** is a comprehensive fake news detection system that combines multiple AI/ML technologies to analyze news content for authenticity. The system performs multi-modal analysis using both **text** and **image** content to determine if news articles are genuine or fabricated.
+
+### Key Features
+
+- **🔍 Multi-Modal Analysis**: Combines text and image analysis for comprehensive fact-checking
+- **🤖 AI Content Detection**: Identifies AI-generated text and images
+- **🧠 Deep Learning Models**: Uses state-of-the-art neural networks for classification
+- **🔗 External Fact-Checking**: Integrates with Google Fact Check Tools API
+- **📊 Emotion Analysis**: Detects sensationalism in news content
+- **👤 Face Analysis**: Analyzes faces in images for deepfake detection
+- **🌐 Web Interface**: User-friendly web application for easy analysis
+
+## 🏗️ Architecture
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                        FactSight System                         │
+├─────────────────────────────────────────────────────────────────┤
+│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐              │
+│  │   Flask     │  │   Core      │  │  Services   │              │
+│  │   Web App   │  │  Manager    │  │ & Models    │              │
+│  └─────────────┘  └─────────────┘  └─────────────┘              │
+├─────────────────────────────────────────────────────────────────┤
+│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐              │
+│  │   Text      │  │   Image     │  │   Fact      │              │
+│  │  Analysis   │  │  Analysis   │  │  Checking   │              │
+│  └─────────────┘  └─────────────┘  └─────────────┘              │
+├─────────────────────────────────────────────────────────────────┤
+│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐              │
+│  │   LSTM      │  │ EfficientNet│  │   Google    │              │
+│  │ Classifier  │  │    B3       │  │ Fact Check  │              │
+│  └─────────────┘  └─────────────┘  └─────────────┘              │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## 🚀 Installation
+
+### Prerequisites
+
+- Python 3.11+
+- CUDA-compatible GPU (recommended for faster inference)
+- 8GB+ RAM
+- 4GB+ free disk space
+
+### Setup Instructions
+
+1. **Clone the repository**
+   ```bash
+   git clone <repository-url>
+   cd FactSight
+   ```
+
+2. **Install dependencies**
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+3. **Download required models from [HUGGINGFACE](<https://huggingface.co/>)** (if not included)
+   ```bash
+   # Models will be automatically downloaded on first run
+   # or placed in the models/ directory
+   ```
+
+4. **Configure environment**
+   ```bash
+   # Set your Google Fact Check API key in config.py
+   FACT_API_KEY = "your-api-key-here"
+   ```
+
+5. **Run the application**
+   ```bash
+   python app.py
+   ```
+
+6. **Access the web interface**
+   ```
+   Open http://localhost:5000 in your browser
+   ```
+
+## 📖 Usage
+
+### Web Interface
+
+1. **Navigate to the homepage** (`/`)
+2. **Paste news text** in the text area (max 10,000 characters)
+3. **Upload images** related to the news (drag & drop or browse)
+4. **Click "Analyze"** to start the fact-checking process
+5. **View detailed results** including:
+   - Overall authenticity score
+   - Text analysis breakdown
+   - Image analysis results
+   - Fact-checking verification
+   - Emotion analysis
+
+### API Usage
+
+```python
+import requests
+
+# Submit for analysis
+response = requests.post('http://localhost:5000/analyze', json={
+    'text': 'Your news article text here...',
+    'images': [
+        {'data': 'base64-encoded-image-data'}
+    ]
+})
+
+analysis_id = response.json()['analysis_id']
+
+# Get results
+results = requests.get(f'http://localhost:5000/analysis/{analysis_id}')
+```
+
+## 🔬 Services & Models Deep Dive
+
+### Text Analysis Services
+
+#### 1. **AI Text Detection** (`ai_text_service.py`)
+- **Model**: Custom-trained classifier [placeholder for url]
+- **Architecture**: Joblib-based scikit-learn model
+- **Performance**: **99% F1-Score**
+- **Purpose**: Distinguishes between AI-generated and human-written text
+- **Features**: Text preprocessing, feature extraction, binary classification
+
+#### 2. **Fake News Classification** (`fake_text_news_service.py`)
+- **Model**: Custom LSTM Neural Network [placeholder for url]
+- **Architecture**:
+  - Embedding layer (100 dimensions)
+  - Bidirectional LSTM (128 hidden units)
+  - Dropout regularization (0.5)
+  - Sigmoid output layer
+- **Performance**: **99% F1-Score**
+- **Purpose**: Classifies news as fake or real
+- **Features**:
+  - Text cleaning and preprocessing
+  - Contraction expansion
+  - Stopword removal
+  - Sequence padding/truncation (300 tokens)
+
+#### 3. **Emotion Analysis** (`text_emotion_service.py`)
+- **Model**: `j-hartmann/emotion-english-distilroberta-base`
+- **Architecture**: DistilRoBERTa transformer model
+- **Purpose**: Detects emotional tone (anger, fear, joy, etc.)
+- **Features**:
+  - Chunked processing for long texts
+  - Confidence-weighted aggregation
+  - Sensationalism detection
+
+#### 4. **Search Query Extraction** (`search_queries_service.py`)
+- **Model**: `transformers` pipeline for question generation
+- **Purpose**: Extracts key claims from text for fact-checking
+- **Features**: NLP-based query generation
+
+### Image Analysis Services
+
+#### 1. **AI Image Detection** (`ai_image_service.py`)
+- **Model**: Custom EfficientNet-B3 [placeholder for url]
+- **Architecture**:
+  - EfficientNet-B3 backbone
+  - Custom classification head
+  - Binary classification (AI vs Real)
+- **Performance**: **99% F1-Score**
+- **Purpose**: Identifies AI-generated vs real images
+- **Features**:
+  - 300x300 input resolution
+  - Batch normalization
+  - GPU acceleration
+
+#### 2. **Face Detection** (`face_detection_service.py`)
+- **Model**: `scrfd` (pre-trained ONNX model)
+- **Purpose**: Detects and locates faces in images
+- **Features**:
+  - Multi-scale face detection
+  - Landmark extraction (eyes, nose, mouth)
+  - Confidence scoring
+  - NMS (Non-Maximum Suppression)
+
+#### 3. **Deepfake Detection** (`deepfake_service.py`)
+- **Model**: Meso4 architecture (two variants)
+  - `Meso4_DF.h5`: Trained on DeepFake dataset
+  - `Meso4_F2F.h5`: Trained on Face2Face dataset
+- **Architecture**:
+  - 4 convolutional layers
+  - Batch normalization
+  - Max pooling
+  - Dropout (0.5)
+  - Sigmoid classification
+- **Purpose**: Detects manipulated faces in images
+- **Features**:
+  - Dual-model ensemble
+  - Face cropping integration
+  - Confidence threshold adjustment
+
+### Fact-Checking Integration
+
+#### **Fact Check Service** (`fact_search_service.py`)
+- **API**: Google Fact Check Tools API v1alpha1
+- **Purpose**: External verification of claims
+- **Features**:
+  - Multi-source fact-checking
+  - Verdict aggregation
+  - Confidence scoring
+  - Source credibility assessment
+
+## 📊 Model Performance
+
+| Model | Type | F1-Score | Dataset | Purpose |
+|-------|------|----------|---------|---------|
+| **AI Text Detector** | Custom Classifier | **99%** | Custom | AI vs Human Text |
+| **Fake News LSTM** | LSTM Neural Network | **99%** | Custom | Fake vs Real News |
+| **AI Image Detector** | EfficientNet-B3 | **99%** | Custom | AI vs Real Images |
+| **Emotion Detector** | DistilRoBERTa | N/A | Pre-trained | Emotion Analysis |
+| **Face Detector** | SCRFD | N/A | Pre-trained | Face Detection |
+| **Deepfake Detector** | Meso4 | N/A | Custom | Deepfake Detection |
+
+## 🎬 Demo Media Files
+
+The `demo/` folder contains sample media:
+
+
+### Videos
+- <video src="./demo/demo.mp4" controls width="720"></video>
+
+
+### Images
+- `demo1.png` - ![Demo 1](./demo/demo1.png)
+- `demo2.png` - ![Demo 2](./demo/demo2.png)
+- `demo3.png` - ![Demo 3](./demo/demo3.png)
+- `demo4.png` - ![Demo 4](./demo/demo4.png)
+- `demo5.png` - ![Demo 5](./demo/demo5.png)
+- `demo6.png` - ![Demo 6](./demo/demo6.png)
+- `demo7.png` - ![Demo 7](./demo/demo7.png)
+
+## ⚙️ Configuration
+
+### Environment Variables
+
+```python
+# config.py
+class Config:
+    flask: FlaskConfig = FlaskConfig(
+        SECRET_KEY = os.environ.get('SECRET_KEY', 'dev-secret-key'),
+        UPLOAD_FOLDER = 'static/uploads',
+        MAX_CONTENT_LENGTH = 50 * 1024 * 1024  # 50MB
+    )
+
+    service: ServiceConfig = ServiceConfig(
+        FACT_API_KEY = "your-google-fact-check-api-key",
+        FAKENESS_SCORE_THRESHOLD = 0.6,
+        FACE_DETECTION_THRESHOLD = 0.5
+    )
+```
+
+### Model Paths
+
+```python
+# Model file locations
+AI_TEXT_DETECTOR = "./models/ai_text_detector.joblib"
+FAKE_NEWS_DETECTOR = "models/fake_news_detector.pt"
+EFFICIENTNET_AI_IMAGE = "./models/efficientnet_b3_full_ai_image_classifier.pt"
+FACE_DETECTION = "models/face_det_10g.onnx"
+MESO4_DF = "models/Meso4_DF.h5"
+MESO4_F2F = "models/Meso4_F2F.h5"
+```
+
+## 🔗 API Endpoints
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| GET | `/` | Main analysis interface |
+| POST | `/analyze` | Submit content for analysis |
+| GET | `/analysis/<id>` | View analysis results |
+| GET | `/health` | System health check |
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+### Development Guidelines
+
+- Follow PEP 8 style guidelines
+- Add tests for new features
+- Update documentation
+- Ensure model compatibility
+
+## 📝 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+##  Acknowledgments
+
+- **Hugging Face** for transformer models and pipelines
+- **Google** for Fact Check Tools API
+- **PyTorch Team** for deep learning framework
+- **OpenCV** for computer vision utilities
+- **SCRFD** for face detection models
+
+##  Support
+
+For support and questions:
+- Create an issue in the repository
+- Contact: [your-email@example.com]
+
+##  Version History
+
+### v1.0.0
+- Initial release with full multi-modal fake news detection
+- 99% F1-scores on custom trained models
+- Comprehensive web interface
+- Integration with external fact-checking services
+
+---
+
+**FactSight** - Bringing truth to the digital age through advanced AI-powered analysis. 🛡️

app.py

@@ -0,0 +1,170 @@
+from flask import Flask, render_template, request, jsonify, redirect, url_for
+from dataclasses import dataclass, asdict, is_dataclass
+from typing import List, Optional, Tuple, Any
+import os
+import uuid
+import base64
+import io
+from datetime import datetime
+from PIL import Image
+
+# Import configuration
+from config import general_config
+
+# -----------------------------
+# Configuration and Setup
+# -----------------------------
+
+# Initialize Flask app with configuration
+app = Flask(__name__)
+app.config['UPLOAD_FOLDER'] = general_config.flask.UPLOAD_FOLDER
+app.config['MAX_CONTENT_LENGTH'] = general_config.flask.MAX_CONTENT_LENGTH
+
+# -----------------------------
+# Data models (matching your schema)
+# -----------------------------
+
+from schemas.fact_search_schemas import FactCheckEntry, FactCheckResult
+from schemas.text_schemas import EmotionResult
+from schemas.vision_schemas import FaceMainPoints
+from schemas.fake_manager_schemas import ImageAnalysis, AggregatedNewsAnalysis
+from core.fake_manager import FakeNewsManager
+from schemas.fake_manager_schemas import News
+
+from services.ai_text_service import NBAITextDetector
+from services.fake_text_news_service import FakeTextNewsDetector
+from services.search_quries_service import TransformersSearchQueryExtractor
+from services.text_emotion_service import TransformersEmotionDetector
+from services.fact_search_service import FactCheckService
+from services.ai_image_service import ENetAIImageDetector
+from services.face_detection_service import SCRFDFaceDetector
+from services.deepfake_service import Meso4FakeFaceDetector
+from models.models import LSTMClassifier
+
+
+# In-memory store: analysis_id -> JSON dict
+STORE: dict[str, dict] = {}
+
+# -----------------------------
+# Helpers
+# -----------------------------
+def save_image(image_data: str, filename: str | None = None) -> Optional[str]:
+    try:
+        if image_data.startswith('data:image'):
+            header, b64 = image_data.split(',', 1)
+            mime = header.split(';')[0].split(':')[1]  # e.g. image/png
+            ext = {'image/jpeg': 'jpg', 'image/png': 'png', 'image/webp': 'webp'}.get(mime, 'jpg')
+        else:
+            b64 = image_data
+            ext = 'jpg'
+
+        raw = base64.b64decode(b64)
+        img = Image.open(io.BytesIO(raw))
+        img.verify()  # validate
+
+        img = Image.open(io.BytesIO(raw))
+        if img.mode not in ('RGB', 'L'):
+            img = img.convert('RGB')
+
+        if not filename:
+            filename = f"{uuid.uuid4().hex}.{ext}"
+        path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
+        img.save(path, quality=92)
+        return path
+    except Exception as e:
+        print(f"Error saving image: {e}")
+        import traceback
+        traceback.print_exc()
+        return None
+
+def initialize_services():
+    """Initialize and configure all ML services."""
+    return FakeNewsManager(
+        ai_text_detector=NBAITextDetector(general_config.service.models.AI_TEXT_DETECTOR),
+        news_detector=FakeTextNewsDetector(
+            model_path=general_config.service.models.FAKE_NEWS_DETECTOR,
+            vocab_path=general_config.service.models.VOCAB_PATH,
+        ),
+        query_extractor=TransformersSearchQueryExtractor(),
+        emotion_detector=TransformersEmotionDetector(),
+        fact_checker=FactCheckService(api_key=general_config.service.FACT_API_KEY),
+        ai_image_detector=ENetAIImageDetector(general_config.service.models.EFFICIENTNET_AI_IMAGE),
+        face_detector=SCRFDFaceDetector(
+            model_path=general_config.service.models.FACE_DETECTION,
+            threshold_probability=general_config.service.FACE_DETECTION_THRESHOLD,
+            nms=general_config.service.FACE_DETECTION_NMS,
+        ),
+        fake_face_detector=Meso4FakeFaceDetector(
+            df_model_path=general_config.service.models.MESO4_DF,
+            f2f_model_path=general_config.service.models.MESO4_F2F,
+        ),
+    )
+
+
+# Initialize services
+fake_news_manager = initialize_services()
+
+# -----------------------------
+# Routes
+# -----------------------------
+@app.route('/')
+def index():
+    return render_template('index.html')
+
+@app.route('/analyze', methods=['POST'])
+def analyze():
+    try:
+        data = request.get_json()
+        if not data or 'text' not in data or 'images' not in data:
+            return jsonify({'success': False, 'error': 'Invalid request data'}), 400
+
+        text = (data.get('text') or '').strip()
+        if not text:
+            return jsonify({'success': False, 'error': 'News text is required'}), 400
+
+        images_in = data.get('images') or []
+        if not images_in:
+            return jsonify({'success': False, 'error': 'At least one image is required'}), 400
+
+        saved_fs_paths_disk = []
+        saved_fs_paths_web = []
+        for img in images_in:
+            path = save_image(img.get('data', ''))
+            if path:
+                saved_fs_paths_disk.append(path)
+                saved_fs_paths_web.append('/' + path.replace('\\', '/'))
+
+        news = News(text=text, images=saved_fs_paths_disk)
+        analysis = fake_news_manager.analyze(news, fakeness_score_threshold=general_config.service.FAKENESS_SCORE_THRESHOLD)
+        analysis_json = analysis.to_json()
+
+        # Overwrite image paths in the JSON to web paths for frontend rendering
+        for i, img_entry in enumerate(analysis_json.get("images", [])):
+            if i < len(saved_fs_paths_web):
+                img_entry["image_path"] = saved_fs_paths_web[i]
+
+        STORE[analysis_json["analysis_id"]] = analysis_json
+
+        return jsonify({'success': True, 'analysis_id': analysis_json["analysis_id"]})
+    except Exception as e:
+        print("Analysis error:", e)
+        import traceback
+        traceback.print_exc()
+
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+@app.route('/analysis/<analysis_id>')
+def analysis_page(analysis_id):
+    analysis = STORE.get(analysis_id)
+    if not analysis:
+        return redirect(url_for('index'))
+    return render_template('analysis.html', analysis=analysis)
+
+@app.route('/health')
+def health():
+    return jsonify({'status': 'healthy', 'timestamp': datetime.now().isoformat()})
+
+if __name__ == '__main__':
+    print("Starting News Analyzer Server...")
+    print("Server running on http://localhost:5000")
+    app.run(debug=True, host='0.0.0.0', port=5000)

config.py

@@ -0,0 +1,59 @@
+from dataclasses import dataclass, field
+import os
+
+
+
+@dataclass
+class FlaskConfig:
+    """Flask application configuration."""
+    SECRET_KEY: str = field(default_factory=lambda: os.environ.get('SECRET_KEY', 'dev-secret-key'))
+    UPLOAD_FOLDER: str = 'static/uploads'
+    MAX_CONTENT_LENGTH: int = 50 * 1024 * 1024  # 50MB
+
+
+@dataclass
+class ModelPaths:
+    """Model file paths configuration."""
+    # Text detection models
+    AI_TEXT_DETECTOR: str = "./models/ai_text_detector.joblib"
+    FAKE_NEWS_DETECTOR: str = "models/fake_news_detector.pt"
+    VOCAB_PATH: str = "models/word2idx.pt"
+
+    # Image detection models
+    EFFICIENTNET_AI_IMAGE: str = "./models/efficientnet_b3_full_ai_image_classifier.pt"
+    FACE_DETECTION: str = "models/face_det_10g.onnx"
+    MESO4_DF: str = "models/Meso4_DF.h5"
+    MESO4_F2F: str = "models/Meso4_F2F.h5"
+
+
+@dataclass
+class ServiceConfig:
+    """Service-specific configuration parameters."""
+    # Face detection thresholds
+    FACE_DETECTION_THRESHOLD: float = 0.5
+    FACE_DETECTION_NMS: float = 0.5
+
+    # Analysis thresholds
+    FAKENESS_SCORE_THRESHOLD: float = 0.6
+
+    # API Keys
+    FACT_API_KEY: str = "your-google-fact-check"
+
+    # Model paths
+    models: ModelPaths = field(default_factory=ModelPaths)
+
+
+@dataclass
+class Config:
+    """Main application configuration."""
+    flask: FlaskConfig = field(default_factory=FlaskConfig)
+    service: ServiceConfig = field(default_factory=ServiceConfig)
+
+    def __post_init__(self):
+        """Ensure upload folder exists after initialization."""
+        if hasattr(self.flask, 'UPLOAD_FOLDER'):
+            os.makedirs(self.flask.UPLOAD_FOLDER, exist_ok=True)
+
+
+# Global configuration instance
+general_config = Config()

core/fake_manager.py

@@ -0,0 +1,190 @@
+from schemas.text_schemas import AITextDetector
+from schemas.vision_schemas import FakeFaceDetector
+from schemas.vision_schemas import FaceDetector
+from schemas.text_schemas import FakeNewsDetector
+from schemas.vision_schemas import AIImageDetector
+from schemas.text_schemas import EmotionDetector
+from schemas.text_schemas import SearchQueryExtractor
+from schemas.fake_manager_schemas import News, AggregatedNewsAnalysis, ImageAnalysis
+from schemas.vision_schemas import FaceMainPoints
+from services.fact_search_service import FactCheckService
+from utils.utils import open_image
+from typing import List, Optional, Union
+from PIL import Image as PILImage
+from pathlib import Path
+import uuid
+from datetime import datetime
+
+
+class FakeNewsManager:
+    """Manager that aggregates multiple detectors and services to analyze a single
+    news item (text + images) and produce an aggregated analysis.
+
+    Responsibilities:
+    - Run text-based detectors (AI text detector, fake-news/text classifier).
+    - Extract search queries and run fact-checking.
+    - Run emotion analysis on the text.
+    - Run image-level detectors (face detection, AI-image detection, deepfake
+      face detection) and crop faces for per-face analysis.
+
+    Attributes:
+        ai_text_detector: Optional AI text detector; must provide `.detect(text) -> bool|float|None`.
+        fake_face_detector: Optional face-level deepfake detector; must provide `.detect(pil_image) -> bool|float|None`.
+        face_detector: Optional face detector; must provide `.detect(pil_image) -> list[FaceMainPoints]`.
+        news_detector: Optional fake-news/text detector; must provide `.detect(text) -> bool|float|None`.
+        ai_image_detector: Optional AI-image detector; must provide `.detect(pil_image) -> bool|float|None`.
+        query_extractor: Optional extractor that returns list[str] from text.
+        emotion_detector: Optional emotion detector; must provide `.analyze(text)`.
+        fact_checker: Optional fact-check service; must provide `.verify_claim(query)`.
+    """
+
+    ai_text_detector: Optional[AITextDetector]
+    fake_face_detector: Optional[FakeFaceDetector]
+    face_detector: Optional[FaceDetector]
+    news_detector: Optional[FakeNewsDetector]
+    ai_image_detector: Optional[AIImageDetector]
+    query_extractor: Optional[SearchQueryExtractor]
+    emotion_detector: Optional[EmotionDetector]
+    fact_checker: Optional[FactCheckService]
+
+    def __init__(
+        self,
+        *,
+        ai_text_detector: Optional[AITextDetector] = None,
+        fake_face_detector: Optional[FakeFaceDetector] = None,
+        face_detector: Optional[FaceDetector] = None,
+        news_detector: Optional[FakeNewsDetector] = None,
+        ai_image_detector: Optional[AIImageDetector] = None,
+        query_extractor: Optional[SearchQueryExtractor] = None,
+        emotion_detector: Optional[EmotionDetector] = None,
+        fact_checker: Optional[FactCheckService] = None,
+    ) -> None:
+        """Create a FakeNewsManager.
+
+        All parameters are optional; missing detectors/services are simply skipped
+        during analysis. Types are intentionally permissive to accommodate a
+        variety of detector implementations used in this project.
+        """
+        self.ai_text_detector = ai_text_detector
+        self.fake_face_detector = fake_face_detector
+        self.face_detector = face_detector
+        self.news_detector = news_detector
+        self.ai_image_detector = ai_image_detector
+        self.query_extractor = query_extractor
+        self.emotion_detector = emotion_detector
+        self.fact_checker = fact_checker
+
+    def test(self) -> None:
+        """Lightweight method used for quick smoke tests.
+
+        Intended for interactive debugging only; it prints a short marker.
+        """
+        print("test")
+
+    def _crop_face(self, img: PILImage, face_mp: FaceMainPoints) -> PILImage:
+        """Crop a face region from a PIL image using coordinates from
+        a `FaceMainPoints` object.
+
+        Args:
+            img: PIL.Image instance to crop from.
+            face_mp: FaceMainPoints providing `box_start_point` and
+                `box_end_point` coordinates as (x, y) tuples.
+
+        Returns:
+            A new PIL.Image containing only the cropped face region.
+        """
+        x1, y1 = face_mp.box_start_point
+        x2, y2 = face_mp.box_end_point
+        return img.crop((x1, y1, x2, y2))
+
+    def analyze(
+        self,
+        news: News,
+        fakeness_score_threshold: float = 0.6,
+    ) -> AggregatedNewsAnalysis:
+        """Analyze a `News` item and return an `AggregatedNewsAnalysis`.
+
+        The method coordinates text and image analyzers, runs optional
+        fact-checking on extracted queries, and constructs an
+        `AggregatedNewsAnalysis` object that summarizes all results.
+
+        Args:
+            news: `News` object containing `text` (str) and `images` (list of
+                paths or file-like objects) to analyze.
+            fakeness_score_threshold: Float threshold in [0, 1] used by the
+                aggregated analysis to decide the final `is_fake_final_decision`.
+
+        Returns:
+            AggregatedNewsAnalysis populated with detector outputs and a
+            computed final decision.
+        """
+        # Text detectors
+        is_ai_text = self.ai_text_detector.detect(news.text) if self.ai_text_detector else None
+        is_fake_text = self.news_detector.detect(news.text) if self.news_detector else None
+
+        # Query extraction & emotion
+        queries: List[str] = self.query_extractor.extract(news.text) if self.query_extractor else []
+        emotion = self.emotion_detector.analyze(news.text) if self.emotion_detector else None
+
+        # Run fact-checking for each extracted query; if no queries, fall back to full text
+        fact_check: Optional[List[object]] = None
+        if self.fact_checker:
+            fact_check = []
+            targets = queries if queries else [news.text]
+            for q in targets:
+                res = self.fact_checker.verify_claim(q)
+                if res is not None:
+                    fact_check.append(res)
+
+        # Image-level analysis
+        images_analysis: List[ImageAnalysis] = []
+        for img_in in news.images:
+            img = open_image(img_in)
+
+            faces = self.face_detector.detect(img) if self.face_detector else []
+            is_ai_image = self.ai_image_detector.detect(img) if self.ai_image_detector else False
+
+            deepfake_faces: List[bool] = []
+            if self.fake_face_detector and faces:
+                for f in faces:
+                    face_img = self._crop_face(img, f)
+                    deepfake_faces.append(bool(self.fake_face_detector.detect(face_img)))
+
+            # Ensure image_path is a string as required by schema
+            if isinstance(img_in, (str, Path)):
+                image_path = str(img_in)
+            else:
+                image_path = ""
+
+            images_analysis.append(
+                ImageAnalysis(
+                    image_path=image_path,
+                    is_ai_image=is_ai_image,
+                    faces=faces,
+                    deepfake_faces=deepfake_faces,
+                )
+            )
+
+        aggregated_news_analysis = AggregatedNewsAnalysis(
+            is_fake_final_decision=None,
+            analysis_timestamp=datetime.now().isoformat(),
+            analysis_id=str(uuid.uuid4()),
+            text=news.text,
+            is_ai_text=is_ai_text,
+            is_fake_text=is_fake_text,
+            queries=queries,
+            emotion=emotion,
+            fact_check=fact_check,
+            images=images_analysis,
+        )
+
+        # Compute final decision using the AggregatedNewsAnalysis helper
+        aggregated_news_analysis.is_fake_final_decision = (
+            aggregated_news_analysis.compute_final_decision(fakeness_score_threshold)
+        )
+
+        return aggregated_news_analysis
+
+
+
+

demo/demo.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:37c5c42334c060547544c1066c4b1eeaadaf56b77335ef574db8eda4c61085c8
+size 27348551

models/Meso4_DF.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:036ed30d04ffd9c7506f825b97c86aa64915f5818931da96817b169aad790af5
+size 156128

models/Meso4_F2F.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bcfda015d217b9f8d6557693edbdf9f4e79cfd22672541968dd0e2954462b5d7
+size 156128

models/ai_text_detector.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:946bba1b68f35d1e95e5245105fc4d1a991f8293df5c3407f7cfa723d359d400
+size 436909018

models/efficientnet_b3_full_ai_image_classifier.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fb6c6ede00a59848ccf176fd1207d421ae8ba7236daa7fe1ac07bfee3e549640
+size 43455736

models/face_det_10g.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5838f7fe053675b1c7a08b633df49e7af5495cee0493c7dcf6697200b85b5b91
+size 16923827

models/fake_news_detector.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6b6dd44b8663bfd062324914918e66c77c419335891c9921e7797f0ef88a920f
+size 4947968

models/models.py

@@ -0,0 +1,27 @@
+import torch.nn as nn
+
+
+
+class LSTMClassifier(nn.Module):
+    def __init__(self, vocab_size, embedding_dim=100, hidden_dim=128,
+                 num_layers=1, dropout=0.5, bidirectional=True):
+        super().__init__()
+        self.embedding = nn.Embedding(vocab_size, embedding_dim, padding_idx=0)
+        self.lstm = nn.LSTM(
+            embedding_dim, hidden_dim, num_layers,
+            batch_first=True,
+            bidirectional=bidirectional,
+            dropout=dropout if num_layers > 1 else 0
+        )
+        self.dropout = nn.Dropout(dropout)
+        self.fc = nn.Linear(hidden_dim * (2 if bidirectional else 1), 1)
+        self.sigmoid = nn.Sigmoid()
+
+    def forward(self, x):
+        x = self.embedding(x)
+        out, _ = self.lstm(x)
+        last = out[:, -1, :]
+        out = self.dropout(last)
+        out = self.fc(out)
+        return self.sigmoid(out).squeeze()
+

models/word2idx.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7bde7101ae6d75cbb8213dac33de55ed1de4e86bfc825e1ef9b549ef10b6e356
+size 201444

requirements.txt

@@ -0,0 +1,13 @@
+numpy==2.3.3
+scikit-learn==1.7.1
+joblib==1.5.2
+onnxruntime==1.22.1
+timm==1.0.15
+torch==2.8.0
+torchvision==0.23.0
+Pillow==11.3.0
+scrfd==0.3.0
+nltk==3.9.1
+contractions==0.1.73
+transformers==4.57.0
+flask==3.1.1

schemas/fact_search_schemas.py

@@ -0,0 +1,36 @@
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+
+
+@dataclass
+class FactCheckEntry:
+    """Represents a single fact-check result from a verified source."""
+    text: str
+    claimant: Optional[str]
+    claim_date: Optional[str]
+    rating: Optional[str]
+    publisher: Optional[str]
+    url: Optional[str]
+
+
+@dataclass
+class FactCheckResult:
+    """Structured result returned by the Fact Check Tools API."""
+    verified: bool
+    summary_verdict: str
+    results: List[FactCheckEntry] = field(default_factory=list)
+
+    def is_fake(self) -> bool:
+        """Return True if the aggregated verdict indicates likely false information."""
+        return self.summary_verdict.lower() in ["false", "likely false", "incorrect"]
+
+    def summary(self) -> str:
+        """Return a human-readable summary for quick inspection."""
+        publishers = {r.publisher for r in self.results if r.publisher}
+        return (
+            f"✅ Verified: {self.verified}\n"
+            f"🧾 Summary Verdict: {self.summary_verdict}\n"
+            f"📚 Sources: {', '.join(publishers) if publishers else 'N/A'}"
+        )
+

schemas/fake_manager_schemas.py

@@ -0,0 +1,178 @@
+from dataclasses import dataclass, asdict, is_dataclass
+from typing import List, Optional, Any, Tuple, Union
+from pathlib import Path
+import numpy as np
+from PIL.Image import Image
+from schemas.vision_schemas import FaceMainPoints
+from schemas.text_schemas import EmotionResult
+from schemas.fact_search_schemas import FactCheckResult
+
+
+
+@dataclass
+class News:
+    text: str
+    images: List[Union[str, Path, Image, np.ndarray]]
+
+
+
+@dataclass
+class IsFakeNewsResult:
+
+    is_fake_text: bool
+    is_ai_text: bool
+    is_deepfake_faces: list[bool]
+
+
+
+
+@dataclass
+class ImageAnalysis:
+    image_path: str
+    is_ai_image: bool
+    faces: List[FaceMainPoints]
+    deepfake_faces: List[bool]
+
+
+
+@dataclass
+class AggregatedNewsAnalysis:
+    is_fake_final_decision: bool
+    text: str
+    is_ai_text: Optional[bool]
+    is_fake_text: Optional[bool]
+    queries: List[str]
+    emotion: Optional["EmotionResult"]
+    fact_check: Optional[List["FactCheckResult"]]
+    images: List["ImageAnalysis"]
+    analysis_timestamp: str
+    analysis_id: str
+
+    # ---------- existing ----------
+    def to_json(self) -> dict:
+        def _convert(obj: Any) -> Any:
+            if is_dataclass(obj):
+                return {k: _convert(v) for k, v in asdict(obj).items()}
+            if isinstance(obj, tuple):
+                return list(obj)
+            if isinstance(obj, list):
+                return [_convert(x) for x in obj]
+            if isinstance(obj, dict):
+                return {k: _convert(v) for k, v in obj.items()}
+            return obj
+        return _convert(self)
+
+    # ---------- NEW: scoring helpers ----------
+    @staticmethod
+    def _score_fact_verdict(verdict: str) -> float:
+        """Map summary_verdict to [0,1] fake-likelihood."""
+        if not verdict:
+            return 0.0
+        v = verdict.strip().lower()
+        table = {
+            "false": 1.0, "pants on fire": 1.0, "fake": 1.0,
+            "likely false": 0.9, "incorrect": 0.9, "misleading": 0.85, "deceptive": 0.85,
+            "unsubstantiated": 0.6, "missing context": 0.5,
+            "mixed": 0.5, "partly false": 0.7, "partly true": 0.3,
+            "mostly true": 0.1, "true": 0.0, "correct": 0.0
+        }
+        # fuzzy match by containment if exact key not present
+        for k, s in table.items():
+            if k in v:
+                return s
+        return 0.0
+
+    @staticmethod
+    def _score_fact_checks(fact_checks: Optional[List["FactCheckResult"]]) -> float:
+        if not fact_checks:
+            return 0.0
+        # take the strongest (max) verdict score across checks
+        return max((AggregatedNewsAnalysis._score_fact_verdict(fc.summary_verdict) for fc in fact_checks if fc and fc.summary_verdict), default=0.0)
+
+    @staticmethod
+    def _score_text(is_fake_text: Optional[bool], is_ai_text: Optional[bool]) -> float:
+        score = 0.0
+        if is_fake_text is True:
+            score += 0.7
+        elif is_fake_text is False:
+            score += 0.0  # explicit non-fake does not add risk
+
+        # AI text alone is NOT proof of fake; small nudge only
+        if is_ai_text is True:
+            score += 0.1
+        elif is_ai_text is False:
+            score += 0.0
+        return min(score, 1.0)
+
+    @staticmethod
+    def _score_images(images: List["ImageAnalysis"]) -> float:
+        if not images:
+            return 0.0
+        # per-image risk
+        per_image = []
+        for img in images:
+            s = 0.0
+            if getattr(img, "is_ai_image", False):
+                s = max(s, 0.5)
+            # deepfake face => strong signal
+            if any(bool(x) for x in getattr(img, "deepfake_faces", []) or []):
+                s = max(s, 0.8)
+            per_image.append(s)
+
+        if not per_image:
+            return 0.0
+
+        # Combine by "noisy OR": 1 - Π(1 - s_i)
+        from math import prod
+        return 1.0 - prod(1.0 - s for s in per_image)
+
+    @staticmethod
+    def _score_emotion(emotion: Optional["EmotionResult"]) -> float:
+        # Small bump only if highly sensational and confident
+        if not emotion:
+            return 0.0
+        dom = (emotion.dominant_emotion or "").strip().lower()
+        conf = float(getattr(emotion, "confidence", 0.0) or 0.0)
+        sensational = {"anger", "fear", "surprise", "disgust"}
+        if dom in sensational and conf >= 0.75:
+            return 0.1
+        return 0.0
+
+    def _active_weights(self, w_fact=0.5, w_text=0.3, w_img=0.15, w_emote=0.05) -> Tuple[float, float, float, float]:
+        """Re-normalize weights if any component is missing."""
+        have_fact = bool(self.fact_check)
+        have_text = (self.is_fake_text is not None) or (self.is_ai_text is not None)
+        have_img  = bool(self.images)
+        have_emo  = bool(self.emotion)
+
+        parts = [
+            (w_fact if have_fact else 0.0),
+            (w_text if have_text else 0.0),
+            (w_img  if have_img  else 0.0),
+            (w_emote if have_emo else 0.0),
+        ]
+        total = sum(parts) or 1.0
+        return tuple(p / total for p in parts)  # normalized
+
+    def compute_final_score(self) -> tuple[float, dict]:
+        """Return (score, breakdown) in [0,1]."""
+        wf, wt, wi, we = self._active_weights()
+
+        s_fact = self._score_fact_checks(self.fact_check)
+        s_text = self._score_text(self.is_fake_text, self.is_ai_text)
+        s_img  = self._score_images(self.images)
+        s_emo  = self._score_emotion(self.emotion)
+
+        score = wf * s_fact + wt * s_text + wi * s_img + we * s_emo
+        breakdown = {
+            "weights": {"fact": wf, "text": wt, "images": wi, "emotion": we},
+            "components": {"fact": s_fact, "text": s_text, "images": s_img, "emotion": s_emo},
+            "total": score
+        }
+        return score, breakdown
+
+    def compute_final_decision(self, threshold: float = 0.60) -> bool:
+        """Set and return final decision based on weighted score."""
+        score, _ = self.compute_final_score()
+        self.is_fake_final_decision = bool(score >= threshold)
+        return self.is_fake_final_decision

schemas/text_schemas.py

@@ -0,0 +1,71 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Dict, List
+
+
+class AITextDetector(ABC):
+    """
+    Abstract base class for all AI text detectors.
+    Defines the interface that all concrete detectors must implement.
+    """
+
+    @abstractmethod
+    def detect(self, text: str) -> bool:
+        """
+        Detect whether the given text is AI-generated.
+
+        Args:
+            text (str): The input text to analyze.
+
+        Returns:
+            bool: True if the text is AI-generated, False if it is human-written.
+        """
+        pass
+
+
+class EmotionDetector(ABC):
+    """Abstract base class for emotion detection."""
+
+    @abstractmethod
+    def analyze(self, text: str):
+        """Analyze the emotion in the given text and return a structured result."""
+        pass
+
+
+@dataclass
+class EmotionResult:
+    """Structured output for detected emotions."""
+    dominant_emotion: str
+    confidence: float
+    all_scores: Dict[str, float]
+
+
+class SearchQueryExtractor(ABC):
+    """Abstract base class for extracting search queries from text."""
+
+    @abstractmethod
+    def extract(self, text: str, num_queries: int = 5) -> List[str]:
+        """
+        Extract search-like queries from a given paragraph.
+
+        Args:
+            text: The input text to extract queries from.
+            num_queries: Number of queries to generate.
+
+        Returns:
+            List[str]: A list of extracted search queries.
+        """
+        pass
+
+
+
+
+from abc import ABC, abstractmethod
+
+
+# ===== Abstract base class =====
+class FakeNewsDetector(ABC):
+    @abstractmethod
+    def detect(self, text: str) -> int:
+        """Return 1 for real news, 0 for fake news."""
+        pass

schemas/vision_schemas.py

@@ -0,0 +1,94 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import List, Tuple
+from PIL import Image
+from scrfd import Face
+import numpy as np
+import os
+from pathlib import Path
+
+
+class AIImageDetector(ABC):
+    """
+    Abstract base class for AI image detectors.
+    """
+
+    @abstractmethod
+    def detect(self, image: Image.Image) -> bool:
+        """
+        Detect whether the given image is AI-generated.
+
+        Args:
+            image (PIL.Image.Image): The input image.
+
+        Returns:
+            bool: True if AI-generated, False if real.
+        """
+        pass
+
+
+@dataclass
+class FaceMainPoints:
+    """
+    The main points of the face.
+
+    Attributes:
+    box_start_point (Tuple[int, int]): The start point of the bounding box.
+    box_end_point (Tuple[int, int]): The end point of the bounding box.
+    box_probabilty_score (float): The probability score of the bounding box.
+    left_eye (Tuple[int, int], optional): The left eye coordinates. Defaults to (0, 0).
+    right_eye (Tuple[int, int], optional): The right eye coordinates. Defaults to (0, 0).
+    nose (Tuple[int, int], optional): The nose coordinates. Defaults to (0, 0).
+    left_mouth (Tuple[int, int], optional): The left mouth coordinates. Defaults to (0, 0).
+    right_mouth (Tuple[int, int], optional): The right mouth coordinates. Defaults to (0, 0).
+    """
+    box_start_point: Tuple[int, int]
+    box_end_point: Tuple[int, int]
+    box_probabilty_score: float
+    left_eye: Tuple[int, int] = (0, 0)
+    right_eye: Tuple[int, int] = (0, 0)
+    nose: Tuple[int, int] = (0, 0)
+    left_mouth: Tuple[int, int] = (0, 0)
+    right_mouth: Tuple[int, int] = (0, 0)
+
+
+class FaceDetector(ABC):
+    """
+    The face detector interface.
+    """
+
+    @abstractmethod
+    def detect(self, image_path: str) -> List[FaceMainPoints]:
+        """
+        Detect the faces in an image.
+
+        Args:
+        image_path (str): The path to the image.
+
+        Returns:
+        A list of FaceMainPoints objects, one for each face in the image.
+        """
+        pass
+
+    @abstractmethod
+    def convert_face_to_face_main_points(self, face: Face) -> FaceMainPoints:
+        """
+        Convert a Face object to a FaceMainPoints object.
+
+        Args:
+        face (Face): The face to convert.
+
+        Returns:
+        A FaceMainPoints object.
+        """
+        pass
+
+
+class FakeFaceDetector(ABC):
+    @abstractmethod
+    def detect(self, image: Image.Image, threshold: float = 0.5) -> bool:
+        """
+        Base detector method.
+        Subclasses must implement this.
+        """
+        raise NotImplementedError("Subclasses should implement this method.")

services/ai_image_service.py

@@ -0,0 +1,76 @@
+import torch
+import timm
+from torchvision import transforms
+from PIL import Image
+from typing import Any
+from schemas.vision_schemas import AIImageDetector
+
+
+class ENetAIImageDetector(AIImageDetector):
+    """
+    EfficientNet-B3 AI Image Detector that classifies whether an image
+    is AI-generated or real using a pre-trained PyTorch model.
+
+    Attributes:
+        model_path (str): Path to the trained model file (.pt).
+        model (Any): Loaded PyTorch model.
+        device (str): Device to run inference on ('cuda' or 'cpu').
+    """
+
+    def __init__(self, model_path: str = "./models/efficientnet_b3_full_ai_image_classifier.pt"):
+        """
+        Initialize the ENetAIImageDetector.
+
+        Args:
+            model_path (str, optional): Path to the trained EfficientNet model.
+        """
+        self.model_path = model_path
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.model = self._load_model()
+        self.transform = self._build_transform()
+
+    def _load_model(self) -> Any:
+        """Load the trained EfficientNet-B3 model."""
+        if self.model_path.endswith(".pt"):
+            model = torch.load(self.model_path, map_location=self.device, weights_only=False)
+        else:
+            model = timm.create_model("efficientnet_b3", pretrained=False, num_classes=1)
+            model.load_state_dict(torch.load(self.model_path, map_location=self.device))
+        model.to(self.device)
+        model.eval()
+        return model
+
+    def _build_transform(self) -> Any:
+        """Return preprocessing pipeline for input images."""
+        return transforms.Compose([
+            transforms.Resize((300, 300)),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.485, 0.456, 0.406],
+                                 std=[0.229, 0.224, 0.225]),
+        ])
+
+    def _preprocess_image(self, image: Image.Image) -> torch.Tensor:
+        """Convert a PIL Image to a normalized tensor."""
+        return self.transform(image).unsqueeze(0).to(self.device)
+
+    def detect(self, image: Image.Image) -> bool:
+        """
+        Detect whether a given PIL image is AI-generated.
+
+        Args:
+            image (PIL.Image.Image): The input image.
+
+        Returns:
+            bool: True if AI-generated, False if real.
+        """
+        if not isinstance(image, Image.Image):
+            raise TypeError("Input must be a PIL.Image.Image object.")
+
+        img_tensor = self._preprocess_image(image)
+
+        with torch.no_grad():
+            outputs = self.model(img_tensor)
+            prob = torch.sigmoid(outputs).item()
+
+        is_ai_generated = prob >= 0.001
+        return is_ai_generated

services/ai_text_service.py

@@ -0,0 +1,68 @@
+import joblib
+import re
+import string
+from typing import Any
+from nltk.corpus import stopwords
+
+
+from schemas.text_schemas import AITextDetector
+
+
+class NBAITextDetector(AITextDetector):
+    """
+    Naive Bayes AI Text Detector that classifies whether a text
+    is AI-generated or human-written using a pre-trained joblib model.
+
+    Attributes:
+        model_path (str): Path to the saved joblib model.
+        model (Any): Loaded ML model for prediction.
+        min_words (int): Minimum number of words required for valid detection.
+    """
+
+    def __init__(self, model_path: str = "./models/ai_text_detector.joblib", min_words: int = 0):
+        """
+        Initialize the NBAITextDetector.
+
+        Args:
+            model_path (str, optional): Path to the trained joblib model file.
+            min_words (int, optional): Minimum number of words for detection.
+        """
+        self.model_path = model_path
+        self.min_words = min_words
+        self.model = self._load_model()
+        self.stop_words = set(stopwords.words('english'))
+
+    def _load_model(self) -> Any:
+        """Load the trained joblib model."""
+        return joblib.load(self.model_path)
+
+    def _preprocess_text(self, text: str) -> str:
+        """Clean and preprocess the input text."""
+        text = text.lower()
+        text = re.sub(r'\s+', ' ', text.strip())
+        text = text.translate(str.maketrans('', '', string.punctuation))
+        text = ' '.join(word for word in text.split() if word not in self.stop_words)
+        text = re.sub(r'http\S+|www\.\S+', '', text)
+        text = re.sub(r'\S+@\S+\.\S+', '', text)
+        text = re.sub(r'#[A-Za-z0-9_]+', '', text)
+        text = re.sub(r'@[A-Za-z0-9_]+', '', text)
+        text = re.sub(r'\d+', '', text)
+        text = ''.join(ch for ch in text if ch.isprintable())
+        return text
+
+    def detect(self, text: str) -> bool:
+        """
+        Detect whether a given text is AI-generated.
+
+        Args:
+            text (str): Input text to classify.
+
+        Returns:
+            bool: True if AI-generated, False if human-written.
+        """
+        if len(text.split()) < self.min_words:
+            raise ValueError(f"Text must be at least {self.min_words} words long.")
+
+        processed = self._preprocess_text(text)
+        prediction = self.model.predict([processed])
+        return bool(int(prediction[0]) == 1) 

services/deepfake_service.py

@@ -0,0 +1,127 @@
+from PIL import Image
+
+from schemas.vision_schemas import FakeFaceDetector
+
+import cv2
+import numpy as np
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import Conv2D, BatchNormalization, MaxPooling2D, Flatten, Dropout, Dense
+from tensorflow.keras.preprocessing.image import img_to_array
+from PIL import Image
+
+
+class Meso4FakeFaceDetector(FakeFaceDetector):
+    """
+    Deepfake face detector using Meso4 models trained on DF and F2F datasets.
+    Combines both models' predictions for a more robust detection.
+    """
+
+    def __init__(self,
+                 df_model_path: str = "models/Meso4_DF.h5",
+                 f2f_model_path: str = "models/Meso4_F2F.h5",
+                 input_shape=(256, 256, 3)):
+        """
+        Initialize and load both pretrained models.
+
+        Args:
+            df_model_path (str): Path to Meso4 model trained on DeepFake dataset.
+            f2f_model_path (str): Path to Meso4 model trained on Face2Face dataset.
+            input_shape (tuple): Expected input shape for the models.
+        """
+        self.df_model_path = df_model_path
+        self.f2f_model_path = f2f_model_path
+        self.input_shape = input_shape
+
+        # Build both models
+        self.model_df = self._build_meso4()
+        self.model_f2f = self._build_meso4()
+
+        # Load pretrained weights
+        self.model_df.load_weights(self.df_model_path)
+        self.model_f2f.load_weights(self.f2f_model_path)
+
+    # ------------------ Internal Model Builder ------------------
+
+    def _build_meso4(self):
+        """Build the Meso4 CNN model architecture."""
+        model = Sequential()
+
+        model.add(Conv2D(8, (3, 3), activation='relu', padding='same', input_shape=self.input_shape))
+        model.add(BatchNormalization())
+        model.add(MaxPooling2D(pool_size=(2, 2), strides=2))
+
+        model.add(Conv2D(8, (5, 5), activation='relu', padding='same'))
+        model.add(BatchNormalization())
+        model.add(MaxPooling2D(pool_size=(2, 2), strides=2))
+
+        model.add(Conv2D(16, (5, 5), activation='relu', padding='same'))
+        model.add(BatchNormalization())
+        model.add(MaxPooling2D(pool_size=(2, 2), strides=2))
+
+        model.add(Conv2D(16, (5, 5), activation='relu', padding='same'))
+        model.add(BatchNormalization())
+        model.add(MaxPooling2D(pool_size=(4, 4), strides=4))
+
+        model.add(Flatten())
+        model.add(Dropout(0.5))
+        model.add(Dense(16, activation='relu'))
+        model.add(Dense(1, activation='sigmoid'))
+
+        model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
+        return model
+
+    # ------------------ Image Preprocessing ------------------
+
+    def _preprocess_image(self, image: Image.Image) -> np.ndarray:
+        """
+        Preprocess a PIL image for prediction.
+
+        Args:
+            image (PIL.Image): Input face image.
+
+        Returns:
+            np.ndarray: Preprocessed image ready for model input.
+        """
+        img = image.convert("RGB")
+        img = img.resize((256, 256))
+        img = img_to_array(img) / 255.0
+        img = np.expand_dims(img, axis=0)
+        return img
+
+    # ------------------ Detection ------------------
+
+    def detect(self, image: Image.Image, threshold: float = 0.5, verbose=True) -> bool:
+        """
+        Detect whether an input face image is fake or real.
+
+        Args:
+            image (PIL.Image): Input image of a face.
+            threshold (float): Decision threshold (default 0.5).
+
+        Returns:
+            bool: True if fake, False if real.
+        """
+        img = self._preprocess_image(image)
+
+        # Get individual predictions
+        pred_df = float(self.model_df.predict(img, verbose=0)[0][0])
+        pred_f2f = float(self.model_f2f.predict(img, verbose=0)[0][0])
+
+        # Combine predictions (average)
+        combined_pred = (pred_df + pred_f2f) / 2.0
+        
+        if verbose:
+            # Print detailed info
+            print(f"🔍 Meso4_DF Prediction: {pred_df:.4f}")
+            print(f"🔍 Meso4_F2F Prediction: {pred_f2f:.4f}")
+            print(f"⚖️ Combined Score: {combined_pred:.4f}")
+
+        # Determine if fake
+        is_fake = combined_pred >= threshold
+
+        if is_fake:
+            print("🔴 Deepfake detected.")
+        else:
+            print("🟢 Real face detected.")
+
+        return is_fake

services/face_detection_service.py

@@ -0,0 +1,137 @@
+from scrfd import SCRFD, Threshold, Face
+from PIL.Image import Image
+import numpy as np
+from typing import List, Union
+from pathlib import Path
+import os
+
+from schemas.vision_schemas import FaceMainPoints, FaceDetector
+from utils.utils import open_image
+
+
+class SCRFDFaceDetector(FaceDetector):
+    """
+    A face detector using the SCRFD model.
+    """
+
+    def __init__(self, model_path: str, threshold_probability: float, nms:float):
+        """
+        Initializes the face detector.
+
+        Args:
+        model_path: The path to the SCRFD model.
+        threshold_probability: The probability threshold for face detection.
+        nms: The NMS threshold for face detection.
+        """
+        self.model = SCRFD.from_path(model_path)
+        self.threshold = Threshold(probability=threshold_probability, nms=nms)
+
+
+    def convert_face_to_face_main_points(self, face: Face) -> FaceMainPoints:
+        """
+        Converts a Face object to a FaceMainPoints object.
+
+        Args:
+        face: The face to convert.
+
+        Returns:
+        A FaceMainPoints object.
+        """
+        return FaceMainPoints(
+            box_start_point=(face.bbox.upper_left.x, face.bbox.upper_left.y,),
+            box_end_point=(face.bbox.lower_right.x, face.bbox.lower_right.y),
+            box_probabilty_score=face.probability,
+            left_eye=(face.keypoints.left_eye.x, face.keypoints.left_eye.y),
+            right_eye=(face.keypoints.right_eye.x, face.keypoints.right_eye.y),
+            nose=(face.keypoints.nose.x, face.keypoints.nose.y),
+            left_mouth=(face.keypoints.left_mouth.x, face.keypoints.left_mouth.y),
+            right_mouth=(face.keypoints.right_mouth.x, face.keypoints.right_mouth.y)
+        )
+
+
+    def detect(self, image: Union[str, Path, np.ndarray, Image]) -> List[FaceMainPoints]:
+        """
+        Detect faces in an image and return their main points.
+
+        Args:
+            image: Input image that can be:
+                - str: Path to image file
+                - Path: Path object to image file
+                - np.ndarray: Image array (BGR or RGB)
+                - PILImage.Image: PIL Image object
+
+        Returns:
+            List[FaceMainPoints]: List of face detections, each containing:
+                - Bounding box coordinates
+                - Key facial landmarks (eyes, nose, mouth)
+                - Confidence score
+
+        Note:
+            - Uses a threshold set during initialization for detection confidence
+            - Returns an empty list if no faces are detected
+            - Image is automatically converted to RGB format
+        """
+        image = open_image(image).convert("RGB")
+
+        extracted_faces = self.model.detect(image, threshold=self.threshold)
+
+        faces = [self.convert_face_to_face_main_points(extracted_face) for extracted_face in extracted_faces]
+
+        return faces
+    
+
+    def extract_face_from_image(self, img, face_main_points:FaceMainPoints):
+        """
+        Extract a face from an image using FaceMainPoints coordinates.
+        
+        Args:
+            img: Input PIL Image
+            face_main_points: FaceMainPoints object containing face coordinates
+            
+        Returns:
+            PIL.Image: Cropped face image
+        """
+        start_x, start_y = face_main_points.box_start_point
+        end_x, end_y = face_main_points.box_end_point
+        
+        return img.crop((start_x, start_y, end_x, end_y))
+
+    def cut_extracted_faces(self, image: Union[str, Path, np.ndarray, Image], 
+                           save_path: str = None) -> List[Image]:
+        """
+        Detect and extract all faces from an image, optionally saving them.
+        
+        Args:
+            image: Input image that can be:
+                - str: Path to image file
+                - Path: Path object to image file
+                - np.ndarray: Image array (BGR or RGB)
+                - PILImage.Image: PIL Image object
+            save_path: Optional path to save extracted faces
+                If provided, faces will be saved as 'face_{index}.jpg' in this directory
+                
+        Returns:
+            List[PIL.Image]: List of cropped face images
+        """
+        # Convert input to PIL Image
+        img = open_image(image)
+        
+        # Detect faces and get their main points
+        faces_information = self.detect(img)
+        
+        if not faces_information:
+            return []  # Return empty list if no faces detected
+            
+        # Extract and optionally save each face
+        extracted_faces = []
+        for i, face_info in enumerate(faces_information):
+            face_image = self.extract_face_from_image(img, face_info)
+            extracted_faces.append(face_image)
+            
+            # Save face if save_path is provided
+            if save_path:
+                os.makedirs(save_path, exist_ok=True)
+                face_path = os.path.join(save_path, f'face_{i}.jpg')
+                face_image.save(face_path)
+                
+        return extracted_faces

services/fact_search_service.py

@@ -0,0 +1,77 @@
+import requests
+
+from schemas.fact_search_schemas import FactCheckEntry, FactCheckResult
+
+class FactCheckService:
+    """
+    A service wrapper around the Google Fact Check Tools API (v1alpha1).
+
+    Provides an interface to verify claims and obtain structured verdicts from
+    fact-checking organizations (BBC, PolitiFact, FactCheck.org, etc.).
+
+    Example:
+        >>> service = FactCheckService(api_key="YOUR_API_KEY")
+        >>> result = service.verify_claim("COVID-19 vaccines cause infertility")
+        >>> print(result.summary())
+    """
+
+    BASE_URL = "https://factchecktools.googleapis.com/v1alpha1/claims:search"
+
+    def __init__(self, api_key: str, timeout: int = 10):
+        """
+        Initialize the FactCheckService.
+
+        Args:
+            api_key (str): Google Fact Check Tools API key.
+            timeout (int): Optional. Request timeout in seconds.
+        """
+        self.api_key = api_key
+        self.timeout = timeout
+
+    def verify_claim(self, claim_text: str) -> FactCheckResult:
+        """
+        Verify a text claim using Google's Fact Check Tools API.
+
+        Args:
+            claim_text (str): The claim or post text to fact-check.
+
+        Returns:
+            FactCheckResult: Structured response with verification details.
+        """
+        params = {"query": claim_text, "key": self.api_key}
+
+        try:
+            response = requests.get(self.BASE_URL, params=params, timeout=self.timeout)
+            response.raise_for_status()
+            data = response.json()
+        except requests.RequestException as e:
+            return FactCheckResult(verified=False, summary_verdict=f"Request failed: {e}")
+
+        if "claims" not in data or not data["claims"]:
+            return FactCheckResult(verified=False, summary_verdict="Unverified")
+
+        entries = []
+        for claim in data["claims"]:
+            reviews = claim.get("claimReview", [])
+            for review in reviews:
+                entries.append(
+                    FactCheckEntry(
+                        text=claim.get("text", ""),
+                        claimant=claim.get("claimant"),
+                        claim_date=claim.get("claimDate"),
+                        rating=review.get("textualRating"),
+                        publisher=review.get("publisher", {}).get("name"),
+                        url=review.get("url"),
+                    )
+                )
+
+        # Aggregate verdict
+        verdict_texts = [e.rating.lower() for e in entries if e.rating]
+        if any(v in verdict_texts for v in ["false", "incorrect", "pants on fire", "mostly false"]):
+            summary_verdict = "Likely False"
+        elif any(v in verdict_texts for v in ["true", "mostly true", "accurate"]):
+            summary_verdict = "Likely True"
+        else:
+            summary_verdict = "Mixed / Unclear"
+
+        return FactCheckResult(verified=True, summary_verdict=summary_verdict, results=entries)

services/fake_text_news_service.py

@@ -0,0 +1,132 @@
+from abc import ABC, abstractmethod
+import re
+import torch
+import contractions
+import nltk
+from nltk.corpus import stopwords
+import torch.nn as nn
+
+from schemas.text_schemas import FakeNewsDetector
+from models.models import LSTMClassifier
+
+# Download stopwords (first run only)
+nltk.download('stopwords', quiet=True)
+stop_words = set(stopwords.words('english'))
+
+
+class FakeTextNewsDetector(FakeNewsDetector):
+    """
+    A class for detecting fake news in text articles using a pre-trained LSTM model.
+
+    This class loads a trained PyTorch LSTM classifier and corresponding vocabulary
+    to evaluate whether a given text is real or fake. It performs preprocessing,
+    tokenization, and encoding before feeding the text to the neural network.
+
+    Attributes:
+        model_path (str): Path to the saved PyTorch model file (.pt).
+        vocab_path (str): Path to the saved vocabulary mapping file (.pt).
+        device (torch.device): The computing device used for inference ('cuda' or 'cpu').
+        model (nn.Module): The loaded LSTM model for fake news detection.
+        word2idx (dict): Mapping of words to integer indices for token encoding.
+    """
+
+    def __init__(self, model_path: str = "models/model.pt", vocab_path: str = "models/word2idx.pt", device=None):
+        """
+        Initializes the FakeTextNewsDetector.
+
+        Loads the trained model and vocabulary, sets up the computing device, and
+        prepares the model for inference.
+
+        Args:
+            model_path (str): Path to the pre-trained LSTM model (.pt). Defaults to "models/model.pt".
+            vocab_path (str): Path to the vocabulary mapping file (.pt). Defaults to "models/word2idx.pt".
+            device (torch.device, optional): Torch device ('cuda' or 'cpu').
+                If not provided, automatically detects CUDA availability.
+        """
+        self.device = device or torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        torch.serialization.add_safe_globals([LSTMClassifier])
+
+        # Load vocabulary dictionary
+        self.word2idx = torch.load(vocab_path, map_location=self.device)
+        vocab_size = len(self.word2idx)
+
+        # Load the LSTM model
+        self.model = LSTMClassifier(vocab_size=vocab_size)
+        loaded_model = torch.load(model_path, map_location=self.device, weights_only=False)
+
+        # Support both raw state_dict and full model serialization
+        if isinstance(loaded_model, dict):
+            self.model.load_state_dict(loaded_model)
+        else:
+            self.model.load_state_dict(loaded_model.state_dict())
+
+        self.model.to(self.device)
+        self.model.eval()
+
+    def _clean_text(self, text: str):
+        """
+        Cleans and tokenizes the input text for model inference.
+
+        Steps include:
+          - Expanding contractions (e.g., "don't" → "do not")
+          - Removing non-ASCII characters, HTML tags, URLs, and special symbols
+          - Lowercasing all text
+          - Removing single-letter words and stopwords
+
+        Args:
+            text (str): The input raw text.
+
+        Returns:
+            list[str]: A list of cleaned and filtered tokens.
+        """
+        text = contractions.fix(text)
+        text = text.encode("ascii", "ignore").decode()
+        text = text.lower()
+        text = re.sub(r"http\S+|www\.\S+", "", text)
+        text = re.sub(r"<.*?>", "", text)
+        text = re.sub(r"[^a-z\s]", "", text)
+        text = re.sub(r"\b\w{1}\b", "", text)
+        tokens = [w for w in text.split() if w not in stop_words]
+        return tokens
+
+    def _encode(self, tokens, max_len: int = 300):
+        """
+        Encodes tokens into a fixed-length tensor for model input.
+
+        Each token is mapped to its index in the loaded vocabulary.
+        If the token is unknown, a special <UNK> index is used.
+        The sequence is padded or truncated to the specified length.
+
+        Args:
+            tokens (list[str]): List of word tokens.
+            max_len (int): Maximum sequence length. Defaults to 300.
+
+        Returns:
+            torch.Tensor: Encoded token tensor of shape (1, max_len).
+        """
+        ids = [self.word2idx.get(w, self.word2idx.get("<UNK>", 1)) for w in tokens]
+        if len(ids) < max_len:
+            ids += [self.word2idx.get("<PAD>", 0)] * (max_len - len(ids))
+        else:
+            ids = ids[:max_len]
+        return torch.tensor(ids, dtype=torch.long).unsqueeze(0)
+
+    def detect(self, text: str) -> bool:
+        """
+        Predicts whether the given text is fake or real.
+
+        The method preprocesses the text, encodes it into numerical form,
+        and runs inference using the LSTM model. The output score is a probability
+        between 0 and 1, where values above 0.5 indicate fake news.
+
+        Args:
+            text (str): The input text (article or sentence).
+
+        Returns:
+            bool: True if the text is predicted as fake, False if real.
+        """
+        tokens = self._clean_text(text)
+        seq = self._encode(tokens).to(self.device)
+        with torch.no_grad():
+            score = self.model(seq).item()
+        return score >= 0.5

services/search_quries_service.py

@@ -0,0 +1,48 @@
+from abc import ABC, abstractmethod
+from typing import List
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
+from schemas.text_schemas import SearchQueryExtractor
+
+
+class TransformersSearchQueryExtractor(SearchQueryExtractor):
+    
+    """Transformer-based implementation of the SearchQueryExtractor interface."""
+
+    def __init__(self, model_name: str = "google/flan-t5-small"):
+        """
+        Initialize the lightweight transformer model for search query generation.
+
+        Args:
+            model_name: Hugging Face model name (default: 'google/flan-t5-small').
+        """
+        self.model_name = model_name
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.model = AutoModelForSeq2SeqLM.from_pretrained(model_name)
+
+    def extract(self, text: str, num_queries: int = 5) -> List[str]:
+        """
+        Generate search-like queries using the transformer model.
+
+        Args:
+            text: The input paragraph.
+            num_queries: Number of queries to generate.
+
+        Returns:
+            List[str]: A list of extracted search queries.
+        """
+        prompt = (
+            f"Generate {num_queries} useful and distinct search queries "
+            f"from the following paragraph:\n{text.strip()}"
+        )
+
+        inputs = self.tokenizer(prompt, return_tensors="pt", truncation=True)
+        outputs = self.model.generate(**inputs, max_length=96, num_return_sequences=1)
+        generated_text = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+
+        # Clean and split queries
+        queries = [
+            q.strip("-• \n").rstrip(".")
+            for q in generated_text.split("\n")
+            if q.strip()
+        ]
+        return queries

services/text_emotion_service.py

@@ -0,0 +1,132 @@
+from transformers import pipeline, AutoTokenizer
+from schemas.text_schemas import EmotionResult, EmotionDetector
+from typing import List, Dict
+
+class TransformersEmotionDetector(EmotionDetector):
+    """Emotion detector using a lightweight DistilRoBERTa model from Hugging Face."""
+
+    def __init__(self, model_name: str = "j-hartmann/emotion-english-distilroberta-base"):
+        """
+        Initialize the emotion detection model.
+        Args:
+            model_name: Pretrained Hugging Face model for emotion detection.
+        """
+        self.model_name = model_name
+        self.pipeline = pipeline(
+            "text-classification",
+            model=model_name,
+            return_all_scores=True
+        )
+        # Load tokenizer for proper text truncation
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+
+    def analyze(self, text: str) -> EmotionResult:
+        """
+        Analyze emotion in the given text using chunked processing for long texts.
+        Args:
+            text: The text to analyze.
+        Returns:
+            EmotionResult: Structured result containing dominant emotion and confidence.
+        """
+        # Split text into chunks if it's too long
+        max_tokens_per_chunk = 400  # Conservative limit to leave room for special tokens
+        chunks = self._split_text_into_chunks(text, max_tokens_per_chunk)
+
+        if len(chunks) == 1:
+            # Single chunk - use original logic
+            results: List[List[Dict[str, float]]] = self.pipeline(chunks[0])
+        else:
+            # Multiple chunks - analyze each and aggregate results
+            results: List[List[Dict[str, float]]] = self.pipeline(chunks)
+
+        # Aggregate emotion scores across all chunks
+        aggregated_scores = self._aggregate_emotion_scores(results)
+
+        # Get the most likely emotion
+        dominant_emotion = max(aggregated_scores, key=aggregated_scores.get)
+        confidence = aggregated_scores[dominant_emotion]
+
+        return EmotionResult(
+            dominant_emotion=dominant_emotion,
+            confidence=confidence,
+            all_scores=aggregated_scores
+        )
+
+    def _split_text_into_chunks(self, text: str, max_tokens_per_chunk: int) -> List[str]:
+        """
+        Split text into chunks that fit within token limits.
+        Args:
+            text: The text to split
+            max_tokens_per_chunk: Maximum tokens per chunk
+        Returns:
+            List of text chunks
+        """
+        # Split text into sentences first for better chunk boundaries
+        sentences = text.split('. ')
+        chunks = []
+        current_chunk = ""
+        current_tokens = 0
+
+        for sentence in sentences:
+            sentence = sentence.strip()
+            if not sentence:
+                continue
+
+            # Add period back if it was removed
+            if not sentence.endswith('.'):
+                sentence += '.'
+
+            sentence_tokens = len(self.tokenizer.tokenize(sentence))
+
+            # If adding this sentence would exceed limit, start new chunk
+            if current_tokens + sentence_tokens > max_tokens_per_chunk and current_chunk:
+                chunks.append(current_chunk.strip())
+                current_chunk = sentence
+                current_tokens = sentence_tokens
+            else:
+                if current_chunk:
+                    current_chunk += " " + sentence
+                else:
+                    current_chunk = sentence
+                current_tokens += sentence_tokens
+
+        # Add the last chunk if it exists
+        if current_chunk:
+            chunks.append(current_chunk.strip())
+
+        return chunks
+
+    def _aggregate_emotion_scores(self, results: List[List[Dict[str, float]]]) -> Dict[str, float]:
+        """
+        Aggregate emotion scores from multiple chunks.
+        Args:
+            results: List of emotion classification results from each chunk
+        Returns:
+            Dictionary of aggregated emotion scores
+        """
+        if not results:
+            return {}
+
+        # Collect all emotion scores with weights
+        emotion_totals = {}
+        emotion_weights = {}
+
+        for chunk_results in results:
+            # Get confidence scores for this chunk
+            chunk_scores = {entry["label"]: entry["score"] for entry in chunk_results}
+
+            # Weight by confidence (more confident predictions get higher weight)
+            total_confidence = sum(chunk_scores.values())
+
+            for emotion, score in chunk_scores.items():
+                weight = score / total_confidence if total_confidence > 0 else 0
+                emotion_totals[emotion] = emotion_totals.get(emotion, 0) + score
+                emotion_weights[emotion] = emotion_weights.get(emotion, 0) + 1  # Simple count for now
+
+        # Average the scores across chunks
+        aggregated_scores = {}
+        for emotion in emotion_totals:
+            # Use weighted average based on number of chunks that detected this emotion
+            aggregated_scores[emotion] = emotion_totals[emotion] / emotion_weights[emotion]
+
+        return aggregated_scores

static/css/style.css

@@ -0,0 +1,335 @@
+/* Dark Theme Core */
+:root {
+  --bg-primary: #0a0a0a;
+  --bg-secondary: #111111;
+  --bg-surface:  #161616;
+  --bg-card:     #1d1d1d;
+  --bg-input:    #232323;
+
+  --text-primary:   #ffffff;
+  --text-secondary: #a0a0a0;
+  --text-muted:     #6e6e6e;
+
+  --accent-primary:       #3b82f6;
+  --accent-primary-hover: #2563eb;
+  --accent-success:       #10b981;
+  --accent-warning:       #f59e0b;
+  --accent-error:         #ef4444;
+  --accent-info:          #3b82f6;
+
+  --border-color: #2a2a2a;
+  --border-light: #3a3a3a;
+
+  --shadow-xl: 0 10px 16px rgba(0,0,0,0.35);
+
+  /* sharper borders */
+  --radius-xs: 4px;
+  --radius-sm: 6px;
+  --radius-md: 8px;
+}
+
+* { margin:0; padding:0; box-sizing:border-box; }
+
+body {
+  font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif;
+  background: var(--bg-primary);
+  color: var(--text-primary);
+  line-height: 1.6;
+}
+
+.container { max-width: 1100px; margin: 0 auto; padding: 0 1.5rem; }
+
+/* Header */
+.header {
+  background: var(--bg-secondary);
+  border-bottom: 1px solid var(--border-color);
+  padding: 1rem 0;
+  position: sticky; top: 0; z-index: 10;
+}
+.header-content { display: flex; justify-content: space-between; align-items: center; }
+.logo { font-size: 1.25rem; font-weight: 700; color: var(--text-primary); }
+
+/* Form Section (intro) */
+.analysis-form-section { padding: 3rem 0; background: var(--bg-secondary); }
+.form-container {
+  background: var(--bg-card);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  padding: 2rem;
+  box-shadow: var(--shadow-xl);
+}
+.form-header { text-align: center; margin-bottom: 2rem; }
+.form-header h2 { font-size: 1.75rem; margin-bottom: 0.5rem; }
+.form-header p { color: var(--text-secondary); }
+
+.form-group { margin-bottom: 1.5rem; }
+.form-label {
+  display: flex; justify-content: space-between; align-items: center;
+  font-weight: 600; margin-bottom: 0.5rem; color: var(--text-primary);
+}
+.char-counter { color: var(--text-muted); font-size: 0.9rem; font-weight: 400; }
+
+.form-textarea {
+  width: 100%; min-height: 200px; background: var(--bg-input);
+  border: 1px solid var(--border-light); border-radius: var(--radius-xs);
+  padding: 1rem; color: var(--text-primary); font-size: 1rem; resize: vertical;
+}
+.form-textarea:focus { outline: none; border-color: var(--accent-primary); }
+
+.upload-container { display: flex; flex-direction: column; gap: 1rem; }
+.upload-zone {
+  border: 2px dashed var(--border-light); border-radius: var(--radius-sm);
+  padding: 2rem 1rem; background: var(--bg-input);
+  transition: border-color .2s, background .2s; cursor: pointer;
+}
+.upload-zone:hover, .upload-zone.drag-over {
+  border-color: var(--accent-primary); background: var(--bg-surface);
+}
+.upload-content { display: flex; flex-direction: column; gap: 1rem; align-items: center; text-align: center; }
+.upload-text h4 { font-size: 1.1rem; margin-bottom: 0.25rem; }
+.upload-text p { color: var(--text-secondary); margin-bottom: 0.25rem; }
+.upload-info { font-size: 0.85rem; color: var(--text-muted); }
+.upload-btn {
+  background: var(--accent-primary); color: #fff; border: none;
+  padding: 0.6rem 1.1rem; border-radius: var(--radius-xs); font-weight: 600; cursor: pointer;
+}
+.upload-btn:hover { background: var(--accent-primary-hover); }
+.file-input { display: none; }
+
+.image-previews {
+  display: grid; grid-template-columns: repeat(auto-fill, minmax(120px, 1fr)); gap: 0.75rem;
+}
+.preview-item {
+  position: relative; border-radius: var(--radius-xs); overflow: hidden;
+  background: var(--bg-input); border: 1px solid var(--border-light);
+}
+.preview-image { width: 100%; height: 100px; object-fit: cover; }
+.remove-btn {
+  position: absolute; top: 0.5rem; right: 0.5rem;
+  background: rgba(239, 68, 68, 0.95); color: #fff; border: none;
+  width: 22px; height: 22px; border-radius: 2px; font-size: 0.8rem; cursor: pointer;
+  opacity: 0; transition: opacity .15s;
+}
+.preview-item:hover .remove-btn { opacity: 1; }
+
+/* Actions */
+.form-actions { display: flex; gap: 0.75rem; justify-content: center; margin-top: 1rem; }
+.btn-primary, .btn-secondary {
+  padding: 0.85rem 1.3rem; border-radius: var(--radius-xs); font-weight: 700; cursor: pointer; border: none; min-width: 140px;
+}
+.btn-primary { background: var(--accent-primary); color: #fff; position: relative; }
+.btn-primary:hover:not(:disabled) { background: var(--accent-primary-hover); }
+.btn-primary:disabled { opacity: 0.6; cursor: not-allowed; }
+.btn-secondary { background: transparent; color: var(--text-secondary); border: 1px solid var(--border-light); }
+.btn-secondary:hover { color: var(--text-primary); }
+
+.btn-loader { display: none; }
+.btn-loader.active { display: inline-block; }
+.spinner {
+  width: 16px; height: 16px; border: 2px solid transparent; border-top: 2px solid currentColor;
+  border-radius: 50%; animation: spin 1s linear infinite;
+}
+@keyframes spin { 0%{transform:rotate(0)} 100%{transform:rotate(360deg)} }
+
+/* Toasts */
+.message-container { position: fixed; top: 1rem; right: 1rem; z-index: 1000; }
+.message {
+  background: var(--bg-surface); border: 1px solid var(--border-color);
+  border-left: 3px solid var(--accent-info);
+  border-radius: var(--radius-xs); padding: 0.7rem 1rem; margin-bottom: 0.5rem;
+  display: flex; gap: 0.75rem; transform: translateX(400px); transition: transform .25s ease-out;
+}
+.message.show { transform: translateX(0); }
+.message.success { border-left-color: var(--accent-success); }
+.message.error { border-left-color: var(--accent-error); }
+.message.warning { border-left-color: var(--accent-warning); }
+.message-title { font-weight: 700; font-size: 0.95rem; }
+.message-text { color: var(--text-secondary); font-size: 0.85rem; }
+.message-close { margin-left: auto; background: none; color: var(--text-muted); border: none; cursor: pointer; font-size: 1rem; }
+
+/* Analysis page */
+.analysis-header {
+  background: var(--bg-secondary);
+  border-bottom: 1px solid var(--border-color);
+  padding: 1rem 0;
+}
+.analysis-header .header-content {
+  display: flex; justify-content: space-between; align-items: center; flex-wrap: wrap; gap: 0.75rem;
+}
+.back-button {
+  color: var(--accent-primary); text-decoration: none; font-weight: 700;
+  padding: 0.35rem 0.7rem; border: 1px solid var(--border-light); border-radius: var(--radius-xs);
+}
+.back-button:hover { background: var(--bg-surface); }
+.analysis-meta { display: flex; gap: 0.75rem; color: var(--text-secondary); font-size: 0.9rem; }
+
+.overview-cards {
+  display: grid; grid-template-columns: repeat(auto-fit, minmax(240px, 1fr));
+  gap: 1rem; margin: 1.5rem 0 2rem;
+}
+.overview-card {
+  background: var(--bg-card); border: 1px solid var(--border-color); border-radius: var(--radius-sm);
+  padding: 1rem; transition: transform .15s; display: flex; align-items: center;
+}
+.overview-card:hover { transform: translateY(-1px); }
+.card-success { border-left: 3px solid var(--accent-success); }
+.card-warning { border-left: 3px solid var(--accent-warning); }
+.card-danger  { border-left: 3px solid var(--accent-error); }
+.card-content h3 { font-size: 0.9rem; color: var(--text-secondary); margin-bottom: 0.35rem; }
+.card-value { font-size: 1.35rem; font-weight: 800; margin-bottom: 0.15rem; }
+.card-description { font-size: 0.8rem; color: var(--text-muted); }
+
+.analysis-dashboard { padding: 1rem 0 2.5rem; }
+.dashboard-grid {
+  display: grid; grid-template-columns: 1fr 1fr; gap: 1.5rem; margin-bottom: 2rem;
+}
+.dashboard-column { display: flex; flex-direction: column; gap: 1.25rem; }
+
+.analysis-section {
+  background: var(--bg-card); border: 1px solid var(--border-color); border-radius: var(--radius-sm); overflow: hidden;
+}
+.section-header {
+  background: var(--bg-surface); padding: 1rem 1.25rem; border-bottom: 1px solid var(--border-color);
+  display: flex; justify-content: space-between; align-items: center;
+}
+.section-header h3 { font-size: 1.05rem; font-weight: 800; }
+.section-badge {
+  background: var(--bg-input); color: var(--text-secondary);
+  padding: 0.2rem 0.6rem; border-radius: var(--radius-xs); font-size: 0.8rem; font-weight: 700;
+}
+
+.content-card { padding: 1rem 1.25rem; }
+.content-text { color: var(--text-primary); margin-bottom: 0.75rem; }
+.content-meta { display: flex; gap: 1rem; color: var(--text-muted); font-size: 0.9rem; }
+
+.emotion-card { padding: 1rem 1.25rem; }
+.dominant-emotion { display: flex; align-items: center; gap: 0.75rem; margin-bottom: 1rem; }
+.emotion-tag { background: var(--accent-primary); color: #fff; padding: 0.3rem 0.6rem; border-radius: var(--radius-xs); font-weight: 800; }
+.emotion-breakdown { display: flex; flex-direction: column; gap: 0.6rem; }
+.emotion-item { display: flex; align-items: center; gap: 0.75rem; }
+.emotion-label { min-width: 80px; color: var(--text-secondary); font-size: 0.9rem; }
+.emotion-bar { flex: 1; height: 8px; background: var(--bg-input); border-radius: var(--radius-xs); overflow: hidden; }
+.emotion-fill { height: 100%; background: linear-gradient(90deg, var(--accent-primary), var(--accent-info)); }
+.emotion-score { min-width: 40px; text-align: right; color: var(--text-muted); font-size: 0.9rem; }
+
+.queries-card { padding: 1rem 1.25rem; }
+.queries-grid { display: flex; flex-wrap: wrap; gap: 0.5rem; }
+.query-chip {
+  background: var(--bg-input); color: var(--text-primary);
+  padding: 0.4rem 0.7rem; border-radius: var(--radius-xs); font-size: 0.85rem; border: 1px solid var(--border-light);
+}
+
+/* Fact checks */
+.fact-checks { padding: 1rem 1.25rem; display: flex; flex-direction: column; gap: 1rem; }
+.fact-check-card { border-radius: var(--radius-xs); overflow: hidden; }
+.fact-unverified { background: rgba(239, 68, 68, 0.05); border: 1px solid rgba(239, 68, 68, 0.35); }
+.fact-verified   { background: rgba(16, 185, 129, 0.05); border: 1px solid rgba(16, 185, 129, 0.35); }
+.fact-check-header {
+  display: flex; justify-content: space-between; align-items: center;
+  padding: 0.8rem 1rem; background: var(--bg-surface);
+}
+.fact-verdict { font-weight: 800; }
+.fact-status { padding: 0.3rem 0.6rem; border-radius: var(--radius-xs); font-weight: 800; font-size: 0.8rem; }
+.status-verified { background: var(--accent-success); color: #fff; }
+.status-unverified { background: var(--accent-error); color: #fff; }
+.fact-check-results { padding: 0.8rem 1rem; }
+.fact-item { margin-bottom: 0.9rem; padding-bottom: 0.9rem; border-bottom: 1px solid var(--border-light); }
+.fact-item:last-child { margin-bottom: 0; padding-bottom: 0; border-bottom: none; }
+.fact-source { display: flex; justify-content: space-between; align-items: center; margin-bottom: 0.35rem; }
+.claim-date { color: var(--text-muted); font-size: 0.8rem; }
+.fact-details { display: flex; justify-content: space-between; align-items: flex-start; gap: 1rem; margin-bottom: 0.35rem; }
+.fact-text { flex: 1; color: var(--text-secondary); font-size: 0.95rem; line-height: 1.4; }
+.fact-rating { padding: 0.25rem 0.6rem; border-radius: var(--radius-xs); font-weight: 800; font-size: 0.8rem; white-space: nowrap; }
+.fact-rating.false, .fact-rating.deceptive { background: var(--accent-error); color: #fff; }
+.fact-rating.unsubstantiated { background: var(--accent-warning); color: #fff; }
+.fact-link { color: var(--accent-primary); text-decoration: none; font-size: 0.85rem; }
+.fact-link:hover { text-decoration: underline; }
+
+/* Uploaded images with overlays */
+.uploaded-images-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
+  gap: 1rem;
+  padding: 1rem 1.25rem;
+}
+.vision-card {
+  background: var(--bg-surface);
+  border: 1px solid var(--border-light);
+  border-radius: var(--radius-sm);
+  padding: 0.9rem;
+}
+.vision-header {
+  display: flex; justify-content: space-between; align-items: center;
+  margin-bottom: 0.6rem; border-bottom: 1px solid var(--border-light); padding-bottom: 0.4rem;
+}
+.image-type { padding: 0.2rem 0.55rem; border-radius: var(--radius-xs); font-size: 0.8rem; font-weight: 800; }
+.ai-image { background: var(--accent-warning); color: #fff; }
+.real-image { background: var(--accent-success); color: #fff; }
+
+.image-canvas-wrap {
+  position: relative;
+  width: 100%;
+  background: #111;
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-xs);
+  overflow: hidden;
+}
+.image-canvas-wrap img { display: block; width: 100%; height: auto; }
+.overlay-canvas {
+  position: absolute; inset: 0; width: 100%; height: 100%; pointer-events: none;
+}
+.no-image { color: var(--text-secondary); padding: 1rem; text-align: center; }
+.faces-count { margin-top: 0.6rem; color: var(--text-secondary); }
+
+/* Export */
+.export-section {
+  background: var(--bg-card); border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm); padding: 1.2rem; text-align: center;
+}
+.export-actions { display: flex; gap: 0.75rem; justify-content: center; flex-wrap: wrap; }
+.export-btn {
+  background: var(--bg-surface); color: var(--text-primary); border: 1px solid var(--border-light);
+  padding: 0.7rem 1.0rem; border-radius: var(--radius-xs); cursor: pointer; transition: background .15s, border-color .15s;
+  font-size: 0.9rem; font-weight: 800;
+}
+.export-btn:hover { background: var(--bg-input); border-color: var(--accent-primary); }
+
+/* Responsive */
+@media (max-width: 820px) {
+  .dashboard-grid { grid-template-columns: 1fr; }
+  .form-container { padding: 1.25rem; }
+  .export-actions { flex-direction: column; }
+}
+
+
+
+/* ... keep your existing CSS exactly as-is ... */
+
+/* NEW: inline/compact header inside the analysis form-container */
+.form-header-inline {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: .75rem;
+  padding-bottom: .25rem;
+  border-bottom: 1px solid var(--border-color);
+}
+.form-header-inline .inline-left {
+  display: flex;
+  align-items: center;
+  gap: .75rem;
+}
+.form-header-inline h2 {
+  margin: 0;
+}
+.form-header-inline .analysis-meta {
+  display: flex;
+  gap: .75rem;
+  color: var(--text-secondary);
+  font-size: 0.9rem;
+}
+
+/* NEW: analysis container block spacing (inside the shared card) */
+.analysis-card-block {
+  margin-top: 1rem;
+}

static/js/script.js

@@ -0,0 +1,185 @@
+class IntroController {
+  constructor() {
+    this.state = { uploadedImages: [], isAnalyzing: false };
+    this.cacheEls();
+    if (!this.el.newsForm) return;
+    this.bind();
+  }
+  cacheEls() {
+    this.el = {
+      newsForm: document.getElementById('newsForm'),
+      newsText: document.getElementById('newsText'),
+      fileInput: document.getElementById('fileInput'),
+      uploadArea: document.getElementById('uploadArea'),
+      browseBtn: document.getElementById('browseBtn'),
+      imagePreviews: document.getElementById('imagePreviews'),
+      analyzeBtn: document.getElementById('analyzeBtn'),
+      clearBtn: document.getElementById('clearBtn'),
+      btnLoader: document.getElementById('btnLoader'),
+      charCounter: document.getElementById('charCounter'),
+      messageContainer: document.getElementById('messageContainer')
+    };
+  }
+  bind() {
+    this.el.newsText.addEventListener('input', () => this.updateCharCount());
+    this.el.browseBtn.addEventListener('click', () => this.el.fileInput.click());
+    this.el.fileInput.addEventListener('change', (e) => this.handleFileSelect(e));
+    this.el.uploadArea.addEventListener('click', () => this.el.fileInput.click());
+    this.el.uploadArea.addEventListener('dragover', (e) => this.dragOver(e));
+    this.el.uploadArea.addEventListener('dragleave', (e) => this.dragLeave(e));
+    this.el.uploadArea.addEventListener('drop', (e) => this.drop(e));
+    this.el.newsForm.addEventListener('submit', (e) => this.submit(e));
+    this.el.clearBtn.addEventListener('click', () => this.clearAll());
+  }
+  updateCharCount() {
+    const len = this.el.newsText.value.length;
+    this.el.charCounter.textContent = `${len}/10000`;
+    if (len > 9000) this.el.charCounter.style.color = 'var(--accent-error)';
+    else if (len > 7000) this.el.charCounter.style.color = 'var(--accent-warning)';
+    else this.el.charCounter.style.color = 'var(--text-muted)';
+  }
+  dragOver(e){ e.preventDefault(); this.el.uploadArea.classList.add('drag-over'); }
+  dragLeave(e){ e.preventDefault(); this.el.uploadArea.classList.remove('drag-over'); }
+  drop(e){ e.preventDefault(); this.el.uploadArea.classList.remove('drag-over'); this.processFiles(Array.from(e.dataTransfer.files)); }
+  handleFileSelect(e){ this.processFiles(Array.from(e.target.files)); this.el.fileInput.value = ''; }
+  processFiles(files){
+    files.forEach(file=>{
+      if(!file.type.startsWith('image/')){ this.toast('Invalid File','Please upload only image files','error'); return; }
+      if(file.size > 10*1024*1024){ this.toast('File Too Large','Image must be smaller than 10MB','error'); return; }
+      const reader=new FileReader();
+      reader.onload=(ev)=>{
+        const imageData={ id:Date.now()+Math.random(), name:file.name, size:this.hSize(file.size), data:ev.target.result };
+        this.state.uploadedImages.push(imageData);
+        this.renderPreview(imageData);
+      };
+      reader.readAsDataURL(file);
+    });
+  }
+  hSize(bytes){
+    if(bytes===0) return '0 B';
+    const k=1024, sizes=['B','KB','MB']; const i=Math.floor(Math.log(bytes)/Math.log(k));
+    return `${parseFloat((bytes/Math.pow(k,i)).toFixed(1))} ${sizes[i]}`;
+  }
+  renderPreview(imageData){
+    const el=document.createElement('div');
+    el.className='preview-item';
+    el.innerHTML=`
+      <img src="${imageData.data}" alt="${imageData.name}" class="preview-image">
+      <button type="button" class="remove-btn" data-id="${imageData.id}">×</button>
+    `;
+    this.el.imagePreviews.appendChild(el);
+    el.querySelector('.remove-btn').addEventListener('click',()=>this.removeImage(imageData.id));
+  }
+  removeImage(id){
+    this.state.uploadedImages=this.state.uploadedImages.filter(x=>x.id!==id);
+    const btn=this.el.imagePreviews.querySelector(`[data-id="${id}"]`);
+    btn?.closest('.preview-item')?.remove();
+  }
+  async submit(e){
+    e.preventDefault();
+    if(!this.validate()){ this.toast('Missing Information','Please add both text and at least one image.','error'); return; }
+    if(this.state.isAnalyzing) return;
+    this.state.isAnalyzing=true; this.el.analyzeBtn.disabled=true; this.el.btnLoader.classList.add('active');
+    this.el.analyzeBtn.querySelector('.btn-text').textContent='Analyzing...';
+    try{
+      const payload={ text:this.el.newsText.value.trim(), images:this.state.uploadedImages.map(img=>({name:img.name,data:img.data})) };
+      const res=await fetch('/analyze',{ method:'POST', headers:{'Content-Type':'application/json'}, body:JSON.stringify(payload) });
+      const json=await res.json();
+      if(json.success){ window.location.href=`/analysis/${json.analysis_id}`; }
+      else{ throw new Error(json.error || 'Analysis failed'); }
+    }catch(err){
+      console.error(err); this.toast('Analysis Failed', err.message,'error');
+    }finally{
+      this.state.isAnalyzing=false; this.el.analyzeBtn.disabled=false; this.el.btnLoader.classList.remove('active');
+      this.el.analyzeBtn.querySelector('.btn-text').textContent='Analyze News';
+    }
+  }
+  validate(){ return this.el.newsText.value.trim().length>0 && this.state.uploadedImages.length>0; }
+  clearAll(){
+    this.el.newsText.value=''; this.state.uploadedImages=[]; this.el.imagePreviews.innerHTML=''; this.updateCharCount();
+    this.toast('Cleared','All inputs have been reset.','success');
+  }
+  toast(title,text,type='info'){
+    const msg=document.createElement('div'); msg.className=`message ${type}`;
+    msg.innerHTML=`<div class="message-content"><div class="message-title">${title}</div><div class="message-text">${text}</div></div><button class="message-close">×</button>`;
+    const root=document.getElementById('messageContainer') || document.body; root.appendChild(msg);
+    setTimeout(()=>msg.classList.add('show'),50);
+    msg.querySelector('.message-close').addEventListener('click',()=>this.hideToast(msg));
+    setTimeout(()=>this.hideToast(msg),5000);
+  }
+  hideToast(msg){ msg.classList.remove('show'); setTimeout(()=>msg.remove(),250); }
+}
+
+class OverlayController {
+  constructor() {
+    const dataEl = document.getElementById('analysis-data');
+    if (!dataEl) return;
+    try { this.analysis = JSON.parse(dataEl.textContent || '{}'); }
+    catch { this.analysis = null; }
+    if (!this.analysis || !Array.isArray(this.analysis.images)) return;
+    this.initOverlays();
+    window.addEventListener('resize', () => this.redrawAll());
+  }
+  initOverlays() {
+    const imgs = document.querySelectorAll('.image-with-overlay');
+    imgs.forEach(img => {
+      if (img.complete) this.setupCanvasFor(img);
+      else img.onload = () => this.setupCanvasFor(img);
+    });
+  }
+  setupCanvasFor(imgEl) {
+    const idx = parseInt(imgEl.dataset.index, 10);
+    const canvas = document.querySelector(`.overlay-canvas[data-index="${idx}"]`);
+    if (!canvas) return;
+    const rect = imgEl.getBoundingClientRect();
+    const dpr = window.devicePixelRatio || 1;
+    canvas.width  = Math.floor(rect.width  * dpr);
+    canvas.height = Math.floor(rect.height * dpr);
+    const ctx = canvas.getContext('2d');
+    ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+    const natW = imgEl.naturalWidth || rect.width;
+    const natH = imgEl.naturalHeight || rect.height;
+    const sx = rect.width / natW;
+    const sy = rect.height / natH;
+    this.drawFaces(ctx, this.analysis.images[idx], sx, sy);
+  }
+  redrawAll() {
+    document.querySelectorAll('.image-with-overlay').forEach(img => this.setupCanvasFor(img));
+  }
+  drawFaces(ctx, imageAnalysis, sx, sy) {
+    const faces = imageAnalysis.faces || [];
+    const deepfakes = imageAnalysis.deepfake_faces || [];
+    const BOX_COLOR = '#ef4444';
+    const BOX_COLOR_DF = '#f59e0b';
+    const POINT_COLOR = '#10b981';
+    const POINT_COLOR_DF = '#f59e0b';
+    const LINE_W = 2;
+    ctx.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height);
+    faces.forEach((f, i) => {
+      const isDF = !!deepfakes[i];
+      const stroke = isDF ? BOX_COLOR_DF : BOX_COLOR;
+      const dot    = isDF ? POINT_COLOR_DF : POINT_COLOR;
+      ctx.lineWidth = LINE_W;
+      ctx.strokeStyle = stroke;
+      const x1 = f.box_start_point[0] * sx + 0.5;
+      const y1 = f.box_start_point[1] * sy + 0.5;
+      const x2 = f.box_end_point[0]   * sx + 0.5;
+      const y2 = f.box_end_point[1]   * sy + 0.5;
+      ctx.strokeRect(x1, y1, x2 - x1, y2 - y1);
+      const drawPoint = (pt) => {
+        const px = pt[0] * sx, py = pt[1] * sy, size = 4;
+        ctx.fillStyle = dot; ctx.fillRect(px - size/2, py - size/2, size, size);
+      };
+      drawPoint(f.left_eye);
+      drawPoint(f.right_eye);
+      drawPoint(f.nose);
+      drawPoint(f.left_mouth);
+      drawPoint(f.right_mouth);
+    });
+  }
+}
+
+document.addEventListener('DOMContentLoaded', () => {
+  new IntroController();
+  new OverlayController();
+});