Merge branch 'Testing'

.env-example

@@ -0,0 +1,34 @@
+MY_SECRET_TOKEN="SECRET_CODE_TOKEN"
+
+# CHROMA_HOST = "localhost" (Host gareko address rakhney)
+
+
+# EXAMPLE CONFIGURATIONS FOR DIFFERENT PROVIDERS(Use only one at once)
+# ===========================================
+
+# FOR OPENAI:(PAID)
+# LLM_PROVIDER=openai
+# LLM_API_KEY=sk-your-openai-api-key
+# LLM_MODEL=gpt-3.5-turbo
+# # Other options: gpt-4, gpt-4-turbo-preview, etc.
+
+# FOR GROQ:(FREE: BABAL XA-> prefer this)
+# LLM_PROVIDER=groq
+# LLM_API_KEY=gsk_your-groq-api-key
+# LLM_MODEL=llama-3.3-70b-versatile
+# # Other options: llama-3.1-70b-versatile, mixtral-8x7b-32768, etc.
+
+# FOR OPENROUTER:(FREE: LASTAI RATE LIMIT LAGAUXA)
+# LLM_PROVIDER=openrouter
+# LLM_API_KEY=sk-or-your-openrouter-api-key
+# LLM_MODEL=meta-llama/llama-3.1-8b-instruct:free
+# # Other options: anthropic/claude-3-haiku, google/gemma-7b-it, etc.
+
+# ===========================================
+# ADVANCED CONFIGURATION
+# ===========================================
+# Temperature (0.0 to 1.0) - controls randomness
+# LLM_TEMPERATURE=0.1
+
+# Maximum tokens for response
+# LLM_MAX_TOKENS=4096

.gitignore

@@ -1,174 +1,71 @@
-# Byte-compiled / optimized / DLL files
+# ---- Python Environment ----
+venv/
+.venv/
+env/
+ENV/
+*.pyc
+*.pyo
+*.pyd
 __pycache__/
-*.py[cod]
-*$py.class
-
-# C extensions
-*.so
+**/__pycache__/
+
+# ---- VS Code / IDEs ----
+.vscode/
+.idea/
+*.swp
+
+# ---- Jupyter / IPython ----
+.ipynb_checkpoints/
+*.ipynb
+
+# ---- Model & Data Artifacts ----
+*.pth
+*.pt
+*.h5
+*.ckpt
+*.onnx
+*.joblib
+*.pkl
+
+# ---- Hugging Face Cache ----
+~/.cache/huggingface/
+huggingface_cache/
+
+# ---- Logs and Dumps ----
+*.log
+*.out
+*.err
 
-# Distribution / packaging
-.Python
+# ---- Build Artifacts ----
 build/
-develop-eggs/
 dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-share/python-wheels/
 *.egg-info/
-.installed.cfg
-*.egg
-MANIFEST
-
-# PyInstaller
-#  Usually these files are written by a python script from a template
-#  before PyInstaller builds the exe, so as to inject date/other infos into it.
-*.manifest
-*.spec
-
-# Installer logs
-pip-log.txt
-pip-delete-this-directory.txt
-
-# Unit test / coverage reports
-htmlcov/
-.tox/
-.nox/
-.coverage
-.coverage.*
-.cache
-nosetests.xml
-coverage.xml
-*.cover
-*.py,cover
-.hypothesis/
-.pytest_cache/
-cover/
-
-# Translations
-*.mo
-*.pot
-
-# Django stuff:
-*.log
-local_settings.py
-db.sqlite3
-db.sqlite3-journal
-
-# Flask stuff:
-instance/
-.webassets-cache
-
-# Scrapy stuff:
-.scrapy
-
-# Sphinx documentation
-docs/_build/
-
-# PyBuilder
-.pybuilder/
-target/
-
-# Jupyter Notebook
-.ipynb_checkpoints
-
-# IPython
-profile_default/
-ipython_config.py
-
-# pyenv
-#   For a library or package, you might want to ignore these files since the code is
-#   intended to run in multiple environments; otherwise, check them in:
-# .python-version
-
-# pipenv
-#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
-#   However, in case of collaboration, if having platform-specific dependencies or dependencies
-#   having no cross-platform support, pipenv may install dependencies that don't work, or not
-#   install all needed dependencies.
-#Pipfile.lock
 
-# UV
-#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
-#   This is especially recommended for binary packages to ensure reproducibility, and is more
-#   commonly ignored for libraries.
-#uv.lock
+# ---- System Files ----
+.DS_Store
+Thumbs.db
 
-# poetry
-#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
-#   This is especially recommended for binary packages to ensure reproducibility, and is more
-#   commonly ignored for libraries.
-#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
-#poetry.lock
-
-# pdm
-#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
-#pdm.lock
-#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
-#   in version control.
-#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
-.pdm.toml
-.pdm-python
-.pdm-build/
-
-# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
-__pypackages__/
-
-# Celery stuff
-celerybeat-schedule
-celerybeat.pid
-
-# SageMath parsed files
-*.sage.py
-
-# Environments
+# ---- Environment Configs ----
 .env
-.venv
-env/
-venv/
-ENV/
-env.bak/
-venv.bak/
-
-# Spyder project settings
-.spyderproject
-.spyproject
-
-# Rope project settings
-.ropeproject
-
-# mkdocs documentation
-/site
-
-# mypy
-.mypy_cache/
-.dmypy.json
-dmypy.json
-
-# Pyre type checker
-.pyre/
-
-# pytype static type analyzer
-.pytype/
-
-# Cython debug symbols
-cython_debug/
-
-# PyCharm
-#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
-#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
-#  and can be added to the global gitignore or merged into this file.  For a more nuclear
-#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
-#.idea/
-
-# Ruff stuff:
-.ruff_cache/
-
-# PyPI configuration file
-.pypirc
+.env.*
+
+# ---- Project-specific ----
+Ai-Text-Detector/
+HuggingFace/model/
+
+# ---- Node Projects (if applicable) ----
+node_modules/
+model/
+models/.gitattributes  #<-- This line can stay if you only want to ignore that file, not the whole folder
+
+todo.md
+np_text_model
+IMG_Models
+notebooks
+# Ignore model and tokenizer files
+np_text_model/classifier/sentencepiece.bpe.model
+np_text_model/classifier/tokenizer.json
+
+# vector database
+chroma_data
+chroma_database

Dockerfile

@@ -0,0 +1,26 @@
+# Read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
+# you will also find guides on how best to write your Dockerfile
+
+FROM python:3.10
+
+# Create user first
+RUN useradd -m -u 1000 user
+
+# Install system dependencies (requires root)
+RUN apt-get update && apt-get install -y libgl1
+
+# Switch to non-root user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+# Add TensorFlow environment variables to reduce logging noise
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+RUN python -m spacy download en_core_web_sm || echo "Failed to download model"
+
+COPY --chown=user . /app
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
+

Procfile

@@ -0,0 +1 @@
+web: uvicorn app:app --host 0.0.0.0 --port ${PORT:-8000}

README.md

@@ -1 +1,22 @@
-# aiapi
+---
+title: Testing AI Contain
+emoji: 🤖
+colorFrom: blue
+colorTo: green
+sdk: docker
+sdk_version: "latest"
+app_file: app.py
+pinned: false
+---
+
+# Testing AI Contain
+
+This Hugging Face Space uses **Docker** to run a custom environment for AI content detection.
+
+## How to run locally
+
+```bash
+docker build -t testing-ai-contain .
+docker run -p 7860:7860 testing-ai-contain
+
+```

READMEs.md

@@ -0,0 +1,152 @@
+# AI-Contain-Checker
+
+A modular AI content detection system with support for **image classification**, **image edit detection**, **Nepali text classification**, and **general text classification**. Built for performance and extensibility, it is ideal for detecting AI-generated content in both visual and textual forms.
+
+
+## 🌟 Features
+
+### 🖼️ Image Classifier
+
+* **Purpose**: Classifies whether an image is AI-generated or a real-life photo.
+* **Model**: Fine-tuned **InceptionV3** CNN.
+* **Dataset**: Custom curated dataset with **\~79,950 images** for binary classification.
+* **Location**: [`features/image_classifier`](features/image_classifier)
+* **Docs**: [`docs/features/image_classifier.md`](docs/features/image_classifier.md)
+
+### 🖌️ Image Edit Detector
+
+* **Purpose**: Detects image tampering or post-processing.
+* **Techniques Used**:
+
+  * **Error Level Analysis (ELA)**: Visualizes compression artifacts.
+  * **Fast Fourier Transform (FFT)**: Detects unnatural frequency patterns.
+* **Location**: [`features/image_edit_detector`](features/image_edit_detector)
+* **Docs**:
+
+  * [ELA](docs/detector/ELA.md)
+  * [FFT](docs/detector/fft.md )
+  * [Metadata Analysis](docs/detector/meta.md)
+  * [Backend Notes](docs/detector/note-for-backend.md)
+
+### 📝 Nepali Text Classifier
+
+* **Purpose**: Determines if Nepali text content is AI-generated or written by a human.
+* **Model**: Based on `XLMRClassifier` fine-tuned on Nepali language data.
+* **Dataset**: Scraped dataset of **\~18,000** Nepali texts.
+* **Location**: [`features/nepali_text_classifier`](features/nepali_text_classifier)
+* **Docs**: [`docs/features/nepali_text_classifier.md`](docs/features/nepali_text_classifier.md)
+
+### 🌐 English Text Classifier
+
+* **Purpose**: Detects if English text is AI-generated or human-written.
+* **Pipeline**:
+
+  * Uses **GPT2 tokenizer** for input preprocessing.
+  * Custom binary classifier to differentiate between AI and human-written content.
+* **Location**: [`features/text_classifier`](features/text_classifier)
+* **Docs**: [`docs/features/text_classifier.md`](docs/features/text_classifier.md)
+
+---
+
+## 🗂️ Project Structure
+
+```bash
+AI-Checker/
+│
+├── app.py                  # Main FastAPI entry point
+├── config.py               # Configuration settings
+├── Dockerfile              # Docker build script
+├── Procfile                # Deployment file for Heroku or similar
+├── requirements.txt        # Python dependencies
+├── README.md               # You are here 📘
+│
+├── features/               # Core detection modules
+│   ├── image_classifier/
+│   ├── image_edit_detector/
+│   ├── nepali_text_classifier/
+│   └── text_classifier/
+│
+├── docs/                   # Internal and API documentation
+│   ├── api_endpoints.md
+│   ├── deployment.md
+│   ├── detector/
+│   │   ├── ELA.md
+│   │   ├── fft.md
+│   │   ├── meta.md
+│   │   └── note-for-backend.md
+│   ├── functions.md
+│   ├── nestjs_integration.md
+│   ├── security.md
+│   ├── setup.md
+│   └── structure.md
+│
+├── IMG_Models/             # Saved image classifier model(s)
+│   └── latest-my_cnn_model.h5
+│
+├── notebooks/              # Experimental and debug notebooks
+├── static/                 # Static assets if needed
+└── test.md                 # Test notes
+````
+
+---
+
+## 📚 Documentation Links
+
+* [API Endpoints](docs/api_endpoints.md)
+* [Deployment Guide](docs/deployment.md)
+* [Detector Documentation](docs/detector/)
+
+  * [Error Level Analysis (ELA)](docs/detector/ELA.md)
+  * [Fast Fourier Transform (FFT)](docs/detector/fft.md)
+  * [Metadata Analysis](docs/detector/meta.md)
+  * [Backend Notes](docs/detector/note-for-backend.md)
+* [Functions Overview](docs/functions.md)
+* [NestJS Integration Guide](docs/nestjs_integration.md)
+* [Security Details](docs/security.md)
+* [Setup Instructions](docs/setup.md)
+* [Project Structure](docs/structure.md)
+
+---
+
+## 🚀 Usage
+
+1. **Install dependencies**
+
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+2. **Run the API**
+
+   ```bash
+   uvicorn app:app --reload
+   ```
+
+3. **Build Docker (optional)**
+
+   ```bash
+   docker build -t ai-contain-checker .
+   docker run -p 8000:8000 ai-contain-checker
+   ```
+
+---
+
+## 🔐 Security & Integration
+
+* **Token Authentication** and **IP Whitelisting** supported.
+* NestJS integration guide: [`docs/nestjs_integration.md`](docs/nestjs_integration.md)
+* Rate limiting handled using `slowapi`.
+
+---
+
+## 🛡️ Future Plans
+
+* Add **video classifier** module.
+* Expand dataset for **multilingual** AI content detection.
+* Add **fine-tuning UI** for models.
+
+---
+
+## 📄 License
+
+See full license terms here: [`LICENSE.md`](license.md)

app.py

@@ -0,0 +1,62 @@
+from fastapi import FastAPI, Request
+from slowapi import Limiter, _rate_limit_exceeded_handler
+from fastapi.responses import FileResponse
+from slowapi.middleware import SlowAPIMiddleware
+from slowapi.errors import RateLimitExceeded
+from slowapi.util import get_remote_address
+from fastapi.responses import JSONResponse
+from features.text_classifier.routes import router as text_classifier_router
+from features.nepali_text_classifier.routes import (
+    router as nepali_text_classifier_router,
+)
+from features.image_classifier.routes import router as image_classifier_router
+from features.image_edit_detector.routes import router as image_edit_detector_router
+from fastapi.staticfiles import StaticFiles
+
+from config import ACCESS_RATE
+
+import requests
+
+limiter = Limiter(key_func=get_remote_address, default_limits=[ACCESS_RATE])
+
+app = FastAPI()
+# added the robots.txt
+# Set up SlowAPI
+app.state.limiter = limiter
+app.add_exception_handler(
+    RateLimitExceeded,
+    lambda request, exc: JSONResponse(
+        status_code=429,
+        content={
+            "status_code": 429,
+            "error": "Rate limit exceeded",
+            "message": "Too many requests. Chill for a bit and try again",
+        },
+    ),
+)
+app.add_middleware(SlowAPIMiddleware)
+
+# Include your routes
+app.include_router(text_classifier_router, prefix="/text")
+app.include_router(nepali_text_classifier_router, prefix="/NP")
+app.include_router(image_classifier_router, prefix="/AI-image")
+app.include_router(image_edit_detector_router, prefix="/detect")
+
+
+@app.get("/")
+@limiter.limit(ACCESS_RATE)
+async def root(request: Request):
+    return {
+        "message": "API is working",
+        "endpoints": [
+            "/text/analyse",
+            "/text/upload",
+            "/text/analyse-sentences",
+            "/text/analyse-sentance-file",
+            "/NP/analyse",
+            "/NP/upload",
+            "/NP/analyse-sentences",
+            "/NP/file-sentences-analyse",
+            "/AI-image/analyse",
+        ],
+    }

config.py

@@ -0,0 +1,2 @@
+ACCESS_RATE = "20/minute"
+

docs/api_endpoints.md

@@ -0,0 +1,92 @@
+# 🧩 API Endpoints
+
+### English (GPT-2) - `/text/`
+
+| Endpoint                      | Method | Description                            |
+| ----------------------------- | ------ | -------------------------------------- |
+| `/text/analyse`               | POST   | Classify raw English text              |
+| `/text/analyse-sentences`     | POST   | Sentence-by-sentence breakdown         |
+| `/text/analyse-sentance-file` | POST   | Upload file, per-sentence breakdown    |
+| `/text/upload`                | POST   | Upload file for overall classification |
+| `/text/health`                | GET    | Health check                           |
+
+#### Example: Classify English text
+
+```bash
+curl -X POST http://localhost:8000/text/analyse \
+  -H "Authorization: Bearer <SECRET_TOKEN>" \
+  -H "Content-Type: application/json" \
+  -d '{"text": "This is a sample text for analysis."}'
+```
+
+**Response:**
+
+```json
+{
+  "result": "AI-generated",
+  "perplexity": 55.67,
+  "ai_likelihood": 66.6
+}
+```
+
+#### Example: File upload
+
+```bash
+curl -X POST http://localhost:8000/text/upload \
+  -H "Authorization: Bearer <SECRET_TOKEN>" \
+  -F 'file=@yourfile.txt;type=text/plain'
+```
+
+---
+
+### Nepali (SentencePiece) - `/NP/`
+
+| Endpoint                     | Method | Description                          |
+| ---------------------------- | ------ | ------------------------------------ |
+| `/NP/analyse`                | POST   | Classify Nepali text                 |
+| `/NP/analyse-sentences`      | POST   | Sentence-by-sentence breakdown       |
+| `/NP/upload`                 | POST   | Upload Nepali PDF for classification |
+| `/NP/file-sentences-analyse` | POST   | PDF upload, per-sentence breakdown   |
+| `/NP/health`                 | GET    | Health check                         |
+
+#### Example: Nepali text classification
+
+```bash
+curl -X POST http://localhost:8000/NP/analyse \
+  -H "Authorization: Bearer <SECRET_TOKEN>" \
+  -H "Content-Type: application/json" \
+  -d '{"text": "यो उदाहरण वाक्य हो।"}'
+```
+
+**Response:**
+
+```json
+{
+  "label": "Human",
+  "confidence": 98.6
+}
+```
+
+#### Example: Nepali PDF upload
+
+```bash
+curl -X POST http://localhost:8000/NP/upload \
+  -H "Authorization: Bearer <SECRET_TOKEN>" \
+  -F 'file=@NepaliText.pdf;type=application/pdf'
+```
+
+### Image-Classification -`/verify-image/`
+
+| Endpoint                | Method | Description             |
+| ----------------------- | ------ | ----------------------- |
+| `/verify-image/analyse` | POST   | Classify Image using ML |
+
+#### Example: Image-Classification
+
+```bash
+curl -X POST http://localhost:8000/verify-image/analyse \
+  -H "Authorization: Bearer <SECRET_TOKEN>" \
+  -F 'file=@test1.png'
+```
+
+[🔙 Back to Main README](../README.md)

docs/deployment.md

@@ -0,0 +1,108 @@
+
+#  Deployment 
+
+This project is containerized and deployed on **Hugging Face Spaces** using a custom `Dockerfile`. This guide explains the structure of the Dockerfile and key considerations for deploying FastAPI apps on Spaces with Docker SDK.
+
+---
+
+## 📦 Base Image
+
+```dockerfile
+FROM python:3.9
+````
+
+We use the official Python 3.9 image for compatibility and stability across most Python libraries and tools.
+
+---
+
+## 👤 Create a Non-Root User
+
+```dockerfile
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+```
+
+* Hugging Face Spaces **requires** that containers run as a non-root user with UID `1000`.
+* We also prepend the user's local binary path to `PATH` for Python package accessibility.
+
+---
+
+## 🗂️ Set Working Directory
+
+```dockerfile
+WORKDIR /app
+```
+
+All application files will reside under `/app` for consistency and clarity.
+
+---
+
+## 📋 Install Dependencies
+
+```dockerfile
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+```
+
+* Copies the dependency list with correct file ownership.
+* Uses `--no-cache-dir` to reduce image size.
+* Ensures the latest compatible versions are installed.
+
+---
+
+## 🔡 Download Language Model (Optional)
+
+```dockerfile
+RUN python -m spacy download en_core_web_sm || echo "Failed to download model"
+```
+
+* Downloads the small English NLP model required by SpaCy.
+* Uses `|| echo ...` to prevent build failure if the download fails (optional safeguard).
+
+---
+
+## 📁 Copy Project Files
+
+```dockerfile
+COPY --chown=user . /app
+```
+
+Copies the entire project source into the container, setting correct ownership for Hugging Face's user-based execution.
+
+---
+
+## 🌐 Start the FastAPI Server
+
+```dockerfile
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
+```
+
+* Launches the FastAPI app using `uvicorn`.
+* **Port 7860 is mandatory** for Docker-based Hugging Face Spaces deployments.
+* `app:app` refers to the `FastAPI()` instance in `app.py`.
+
+---
+
+## ✅ Deployment Checklist
+
+* [x] Ensure your main file is named `app.py` or adjust `CMD` accordingly.
+* [x] All dependencies should be listed in `requirements.txt`.
+* [x] If using models like SpaCy, verify they are downloaded or bundled.
+* [x] Test your Dockerfile locally with `docker build` before pushing to Hugging Face.
+
+---
+
+## 📚 References
+
+* Hugging Face Docs: [Spaces Docker SDK](https://huggingface.co/docs/hub/spaces-sdks-docker)
+* Uvicorn Docs: [https://www.uvicorn.org/](https://www.uvicorn.org/)
+* SpaCy Models: [https://spacy.io/models](https://spacy.io/models)
+
+---
+
+Happy deploying!  
+**P.S.** Try not to break stuff. 😅
+
+
+[🔙 Back to Main README](../README.md)

docs/detector/ELA.md

@@ -0,0 +1,65 @@
+# Error Level Analysis (ELA) Detector
+
+This module provides a function to perform Error Level Analysis (ELA) on images to detect potential manipulations or edits.
+
+## Function: `run_ela`
+
+```python
+def run_ela(image: Image.Image, quality: int = 90, threshold: int = 15) -> bool:
+```
+
+### Description
+
+Error Level Analysis (ELA) works by recompressing an image at a specified JPEG quality level and comparing it to the original image. Differences between the two images reveal areas with inconsistent compression artifacts — often indicating image manipulation.
+
+The function computes the maximum pixel difference across all color channels and uses a threshold to determine if the image is likely edited.
+
+### Parameters
+
+| Parameter   | Type        | Default | Description                                                                                 |
+| ----------- | ----------- | ------- | ------------------------------------------------------------------------------------------- |
+| `image`     | `PIL.Image` | N/A     | Input image in RGB mode to analyze.                                                         |
+| `quality`   | `int`       | 90      | JPEG compression quality used for recompression during analysis (lower = more compression). |
+| `threshold` | `int`       | 15      | Pixel difference threshold to flag the image as edited.                                     |
+
+### Returns
+
+`bool`
+
+- `True` if the image is likely edited (max pixel difference > threshold).
+- `False` if the image appears unedited.
+
+### Usage Example
+
+```python
+from PIL import Image
+from detectors.ela import run_ela
+
+# Open and convert image to RGB
+img = Image.open("example.jpg").convert("RGB")
+
+# Run ELA detection
+is_edited = run_ela(img, quality=90, threshold=15)
+
+print("Image edited:", is_edited)
+```
+
+### Notes
+
+- The input image **must** be in RGB mode for accurate analysis.
+- ELA is a heuristic technique; combining it with other detection methods increases reliability.
+- Visualizing the enhanced difference image can help identify edited regions (not returned by this function but possible to add).
+
+### Installation
+
+Make sure you have Pillow installed:
+
+```bash
+pip install pillow
+```
+
+### Running Locally
+
+Just put the function in a notebook or script file and run it with your image. It works well for basic images.
+
+[🔙 Back to Main README](../README.md)

docs/detector/ai_human_image_checker.md

@@ -0,0 +1,132 @@
+Real vs. Fake Image Classification for Production Pipeline
+==========================================================
+
+1\. Business Problem
+--------------------
+
+This project addresses the critical business need to automatically identify and flag manipulated or synthetically generated images. By accurately classifying images as **"real"** or **"fake,"** we can enhance the integrity of our platform, prevent the spread of misinformation, and protect our users from fraudulent content. This solution is designed for integration into our production pipeline to process images in real-time.
+
+2\. Solution Overview
+---------------------
+
+This solution leverages OpenAI's CLIP (Contrastive Language-Image Pre-Training) model to differentiate between real and fake images. The system operates as follows:
+
+1.  **Feature Extraction:** A pre-trained CLIP model ('ViT-L/14') converts input images into 768-dimensional feature vectors.
+    
+2.  **Classification:** A Support Vector Machine (SVM) model, trained on our internal dataset of real and fake images, classifies the feature vectors.
+    
+3.  **Deployment:** The trained model is deployed as a service that can be integrated into our production image processing pipeline.
+    
+
+The model has achieved an accuracy of **98.29%** on our internal test set, demonstrating its effectiveness in distinguishing between real and fake images.
+
+3\. Getting Started
+-------------------
+
+### 3.1. Dependencies
+
+To ensure a reproducible environment, all dependencies are listed in the requirements.txt file. Install them using pip:
+
+```bash
+pip install -r requirements.txt
+```
+
+**requirements.txt**:
+ - numpy 
+ - Pillow  
+ - torch  
+ - clip-by-openai  
+ - scikit-learn  
+ - tqdm  
+ - seaborn  
+ - matplotlib
+
+### 3.2. Data Preparation
+
+The model was trained on a dataset of real and fake images obtained form kaggle the dataset link is https://www.kaggle.com/datasets/tristanzhang32/ai-generated-images-vs-real-images/data$0.
+
+### 3.3. Usage
+
+#### 3.3.1. Feature Extraction
+
+To extract features from a new dataset, run the following command:
+
+```
+ python extract_features.py --data_dir /path/to/your/data --output_file features.npz
+ ```   
+
+#### 3.3.2. Model Training
+
+To retrain the SVM model on a new set of extracted features, run:
+
+```
+python train_model.py --features_file features.npz --model_output_path model.joblib   
+```
+
+#### 3.3.3. Inference
+
+To classify a single image using the trained model, use the provided inference script:
+```
+ python classify.py --image_path /path/to/your/image.jpg --model_path model.joblib  
+ ```
+
+4\. Production Deployment
+-------------------------
+
+The image classification model is deployed as a microservice. The service exposes an API endpoint that accepts an image and returns a classification result ("real" or "fake").
+
+### 4.1. API Specification
+
+*   **Endpoint:** /classify
+    
+*   **Method:** POST
+    
+*   **Request Body:** multipart/form-data with a single field image.
+    
+*   **Response:**
+    
+    *   JSON{ "classification": "real", "confidence": 0.95}
+        
+    *   JSON{ "error": "Error message"}
+        
+
+### 4.2. Scalability and Monitoring
+
+The service is deployed in a containerized environment (e.g., Docker) and managed by an orchestrator (e.g., Kubernetes) to ensure scalability and high availability. Monitoring and logging are in place to track model performance, API latency, and error rates.
+
+5\. Model Versioning
+--------------------
+
+We use a combination of Git for code versioning and a model registry for tracking trained model artifacts. Each model is versioned and associated with the commit hash of the code that produced it. The current production model is **v1.2.0**.
+
+6\. Testing
+-----------
+
+The project includes a suite of tests to ensure correctness and reliability:
+
+*   **Unit tests:** To verify individual functions and components.
+    
+*   **Integration tests:** To test the interaction between different parts of the system.
+    
+*   **Model evaluation tests:** To continuously monitor model performance on a golden dataset.
+    
+
+To run the tests, execute:
+``` 
+pytest   
+```
+
+7\. Future Work
+---------------
+
+*   **Explore more advanced classifiers:** Investigate the use of neural network-based classifiers on top of CLIP features.
+    
+*   **Fine-tune the CLIP model:** For even better performance, we can fine-tune the CLIP model on our specific domain of images.
+    
+*   **Expand the training dataset:** Continuously augment the training data with new examples of real and fake images to improve the model's robustness.
+    
+
+8\. Contact/Support
+-------------------
+
+For any questions or issues regarding this project, please contact the Machine Learning team at [your-team-email@yourcompany.com](mailto:your-team-email@yourcompany.com) .

docs/detector/fft.md

@@ -0,0 +1,136 @@
+
+#  Fast Fourier Transform (FFT) Detector
+
+```python
+def run_fft(image: Image.Image, threshold: float = 0.92) -> bool:
+```
+
+## **Overview**
+
+The `run_fft` function performs a frequency domain analysis on an image using the **Fast Fourier Transform (FFT)** to detect possible **AI generation or digital manipulation**. It leverages the fact that artificially generated or heavily edited images often exhibit a distinct high-frequency pattern.
+
+---
+
+## **Parameters**
+
+| Parameter   | Type              | Description                                                                             |
+| ----------- | ----------------- | --------------------------------------------------------------------------------------- |
+| `image`     | `PIL.Image.Image` | Input image to analyze. It will be converted to grayscale and resized.                  |
+| `threshold` | `float`           | Proportion threshold of high-frequency components to flag the image. Default is `0.92`. |
+
+---
+
+## **Returns**
+
+| Type   | Description                                                            |
+| ------ | ---------------------------------------------------------------------- |
+| `bool` | `True` if image is likely AI-generated/manipulated; otherwise `False`. |
+
+---
+
+## **Step-by-Step Explanation**
+
+### 1. **Grayscale Conversion**
+
+All images are converted to grayscale:
+
+```python
+gray_image = image.convert("L")
+```
+
+### 2. **Resize**
+
+The image is resized to a fixed $512 \times 512$ for uniformity:
+
+```python
+resized_image = gray_image.resize((512, 512))
+```
+
+### 3. **FFT Calculation**
+
+Compute the 2D Discrete Fourier Transform:
+
+$$
+F(u, v) = \sum_{x=0}^{M-1} \sum_{y=0}^{N-1} f(x, y) \cdot e^{-2\pi i \left( \frac{ux}{M} + \frac{vy}{N} \right)}
+$$
+
+```python
+fft_result = fft2(image_array)
+```
+
+### 4. **Shift Zero Frequency to Center**
+
+Use `fftshift` to center the zero-frequency component:
+
+```python
+fft_shifted = fftshift(fft_result)
+```
+
+### 5. **Magnitude Spectrum**
+
+$$
+|F(u, v)| = \sqrt{\Re^2 + \Im^2}
+$$
+
+```python
+magnitude_spectrum = np.abs(fft_shifted)
+```
+
+### 6. **Normalization**
+
+Normalize the spectrum to avoid scale issues:
+
+$$
+\text{Normalized}(u,v) = \frac{|F(u,v)|}{\max(|F(u,v)|)}
+$$
+
+```python
+normalized_spectrum = magnitude_spectrum / max_magnitude
+```
+
+### 7. **High-Frequency Detection**
+
+High-frequency components are defined as:
+
+$$
+\text{Mask}(u,v) = 
+\begin{cases}
+1 & \text{if } \text{Normalized}(u,v) > 0.5 \\
+0 & \text{otherwise}
+\end{cases}
+$$
+
+```python
+high_freq_mask = normalized_spectrum > 0.5
+```
+
+### 8. **Proportion Calculation**
+
+$$
+\text{Ratio} = \frac{\sum \text{Mask}}{\text{Total pixels}}
+$$
+
+```python
+high_freq_ratio = np.sum(high_freq_mask) / normalized_spectrum.size
+```
+
+### 9. **Threshold Decision**
+
+If the ratio exceeds the threshold:
+
+$$
+\text{is\_fake} = (\text{Ratio} > \text{Threshold})
+$$
+
+```python
+is_fake = high_freq_ratio > threshold
+```
+
+it is implemented in the api
+
+### Running Locally
+
+Just put the function in a notebook or script file and run it with your image. It works well for basic images.
+
+
+[🔙 Back to Main README](../README.md)

docs/detector/meta.md

@@ -0,0 +1,20 @@
+# Metadata Analysis for Image Edit Detection
+
+This module inspects image metadata to detect possible signs of AI-generation or post-processing edits.
+
+## Overview
+
+- Many AI-generated images and edited images leave identifiable traces in their metadata.
+- This detector scans image EXIF metadata and raw bytes for known AI generation indicators and common photo editing software signatures.
+- It classifies images as `"ai_generated"`, `"edited"`, or `"undetermined"` based on detected markers.
+- Handles invalid image formats gracefully by reporting errors.
+
+## How It Works
+
+- Opens the image from raw bytes using the Python Pillow library (`PIL`).
+- Reads EXIF metadata and specifically looks for the "Software" tag that often contains the editing app name.
+- Checks for common image editors such as Photoshop, GIMP, Snapseed, etc.
+- Scans the entire raw byte content of the image for embedded AI generation identifiers like "midjourney", "stable-diffusion", "openai", etc.
+- Returns a status string indicating the metadata classification.
+
+[🔙 Back to Main README](../README.md)

docs/detector/note-for-backend.md

@@ -0,0 +1,94 @@
+
+# 📦API integration note
+
+## Overview
+
+This system integrates **three image forensics methods**—**ELA**, **FFT**, and **Metadata analysis**—into a single detection pipeline to determine whether an image is AI-generated, manipulated, or authentic.
+
+---
+
+## 🔍 Detection Modules
+
+### 1. **ELA (Error Level Analysis)**
+
+* **Purpose:** Detects tampering or editing by analyzing compression error levels.
+* **Accuracy:** ✅ *Most accurate method*
+* **Performance:** ❗ *Slowest method*
+* **Output:** `True` (edited) or `False` (authentic)
+
+### 2. **FFT (Fast Fourier Transform)**
+
+* **Purpose:** Identifies high-frequency patterns typical of AI-generated images.
+* **Accuracy:** ⚠️ *Moderately accurate*
+* **Performance:** ❗ *Moderate to slow*
+* **Output:** `True` (likely AI-generated) or `False` (authentic)
+
+### 3. **Metadata Analysis**
+
+* **Purpose:** Detects traces of AI tools or editors in image metadata or binary content.
+* **Accuracy:** ⚠️ *Fast but weaker signal*
+* **Performance:** 🚀 *Fastest method*
+* **Output:** One of:
+
+  * `"ai_generated"` – AI tool or generator identified
+  * `"edited"` – Edited using known software
+  * `"undetermined"` – No signature found
+
+---
+
+## 🧩 Integration Plan
+
+### ➕ Combine all three APIs into one unified endpoint:
+
+```bash
+POST /api/detect-image
+```
+
+### Input:
+
+* `image`: Image file (binary, any format supported by Pillow)
+
+### Output:
+
+```json
+{
+  "ela_result": true,
+  "fft_result": false,
+  "metadata_result": "ai_generated",
+  "final_decision": "ai_generated" 
+}
+```
+> NOTE:Optionally recommending a default logic (e.g., trust ELA > FFT > Metadata).
+
+## Result implementation
+| `ela_result` | `fft_result` | `metadata_result` | Suggested Final Decision | Notes                                                                   |
+| ------------ | ------------ | ----------------- | ------------------------ | ----------------------------------------------------------------------- |
+| `true`       | `true`       | `"ai_generated"`  | `ai_generated`           | Strong evidence from all three modules                                  |
+| `true`       | `false`      | `"edited"`        | `edited`                 | ELA confirms editing, no AI signals                                     |
+| `true`       | `false`      | `"undetermined"`  | `edited`                 | ELA indicates manipulation                                              |
+| `false`      | `true`       | `"ai_generated"`  | `ai_generated`           | No edits, but strong AI frequency & metadata signature                  |
+| `false`      | `true`       | `"undetermined"`  | `possibly_ai_generated`  | Weak metadata, but FFT indicates possible AI generation                 |
+| `false`      | `false`      | `"ai_generated"`  | `ai_generated`           | Metadata alone shows AI use                                             |
+| `false`      | `false`      | `"edited"`        | `possibly_edited`        | Weak signal—metadata shows editing but no structural or frequency signs |
+| `false`      | `false`      | `"undetermined"`  | `authentic`              | No detectable manipulation or AI indicators                             |
+
+
+### Decision Logic:
+
+* Use **ELA** as the **primary indicator** for manipulation.
+* Supplement with **FFT** and **Metadata** to improve reliability.
+* Combine using a simple rule-based or voting system.
+
+---
+
+## ⚙️ Performance Consideration
+
+| Method   | Speed       | Strength             |
+| -------- | ----------- | -------------------- |
+| ELA      | ❗ Slow      | ✅ Highly accurate    |
+| FFT      | ⚠️ Moderate | ⚠️ Somewhat reliable |
+| Metadata | 🚀 Fast     | ⚠️ Low confidence    |
+
+> For high-throughput systems, consider running Metadata first and conditionally applying ELA/FFT if suspicious.
+
+[🔙 Back to Main README](../README.md)

docs/features/image_classifier.md

@@ -0,0 +1,31 @@
+# Image Classifier
+
+## Overview
+
+This module classifies whether an input image is AI-generated or a real-life photograph.
+
+## Model
+
+- Architecture: InceptionV3
+- Type: Binary Classifier (AI vs Real)
+- Format: H5 model (`latest-my_cnn_model.h5`)
+
+## Dataset
+
+- Total images: ~79,950
+- Balanced between real and generated images
+- Preprocessing: Resizing, normalization
+
+## Code Location
+
+- Controller: `features/image_classifier/controller.py`
+- Model Loader: `features/image_classifier/model_loader.py`
+- Preprocessor: `features/image_classifier/preprocess.py`
+
+## API
+
+- Endpoint: [ENDPOINTS](../api_endpoints.md)
+- Input: Image file (PNG/JPG)
+- Output: JSON response with classification result and confidence
+
+[🔙 Back to Main README](../README.md)

docs/features/nepali_text_classifier.md

@@ -0,0 +1,30 @@
+# Nepali Text Classifier
+
+## Overview
+
+This classifier identifies whether Nepali-language text content is written by a human or AI.
+
+## Model
+
+- Base Model: XLM-Roberta (XLMRClassifier)
+- Language: Nepali (Multilingual model)
+- Fine-tuned with scraped web content (~18,000 samples)
+
+## Dataset
+
+- Custom scraped dataset with manual labeling
+- Includes news, blogs, and synthetic content from various LLMs
+
+## Code Location
+
+- Controller: `features/nepali_text_classifier/controller.py`
+- Inference: `features/nepali_text_classifier/inferencer.py`
+- Model Loader: `features/nepali_text_classifier/model_loader.py`
+
+## API
+
+- Endpoint: [ENDPOINTS](../api_endpoints.md)
+- Input: Raw text
+- Output: JSON classification with label and confidence score
+
+[🔙 Back to Main README](../README.md)

docs/features/text_classifier.md

@@ -0,0 +1,30 @@
+# English Text Classifier
+
+## Overview
+
+Detects whether English-language text is AI-generated or human-written.
+
+## Model Pipeline
+
+- Tokenizer: GPT-2 Tokenizer
+- Model: Custom trained binary classifier
+
+## Dataset
+
+- Balanced dataset: Human vs AI-generated (ChatGPT, Claude, etc.)
+- Tokenized and fed into the model using PyTorch/TensorFlow
+
+## Code Location
+
+- Controller: `features/text_classifier/controller.py`
+- Inference: `features/text_classifier/inferencer.py`
+- Model Loader: `features/text_classifier/model_loader.py`
+- Preprocessor: `features/text_classifier/preprocess.py`
+
+## API
+
+- Endpoint: [ENDPOINTS](../api_endpoints.md)
+- Input: Raw English text
+- Output: Prediction result with probability/confidence
+
+[🔙 Back to Main README](../README.md)

docs/functions.md

@@ -0,0 +1,62 @@
+# Major  Functions used 
+
+## in Text Classifier (`features/text_classifier/` and `features/text_classifier/`)
+
+- **`load_model()`**  
+  Loads the GPT-2 model and tokenizer from the specified directory paths.
+
+- **`lifespan()`**  
+  Manages the application lifecycle. Initializes the model at startup and handles cleanup on shutdown.
+
+- **`classify_text_sync()`**  
+  Synchronously tokenizes input text and predicts using the GPT-2 model. Returns classification and perplexity.
+
+- **`classify_text()`**  
+  Asynchronously runs `classify_text_sync()` in a thread pool for non-blocking text classification.
+
+- **`analyze_text()`**  
+  **POST** endpoint: Accepts text input, classifies it using `classify_text()`, and returns the result with perplexity.
+
+- **`health()`**  
+  **GET** endpoint: Simple health check for API liveness.
+
+- **`parse_docx()`, `parse_pdf()`, `parse_txt()`**  
+  Utilities to extract and convert `.docx`, `.pdf`, and `.txt` file contents to plain text.
+
+- **`warmup()`**  
+  Downloads the model repository and initializes the model/tokenizer using `load_model()`.
+
+- **`download_model_repo()`**  
+  Downloads the model files from the designated `MODEL` folder.
+
+- **`get_model_tokenizer()`**  
+  Checks if the model already exists; if not, downloads it—otherwise, loads the cached model.
+
+- **`handle_file_upload()`**  
+  Handles file uploads from the `/upload` route. Extracts text, classifies, and returns results.
+
+- **`extract_file_contents()`**  
+  Extracts and returns plain text from uploaded files (PDF, DOCX, TXT).
+
+- **`handle_file_sentence()`**  
+  Processes file uploads by analyzing each sentence (under 10,000 chars) before classification.
+
+- **`handle_sentence_level_analysis()`**  
+  Checks/strips each sentence, then computes AI/human likelihood for each.
+
+- **`analyze_sentences()`**  
+  Splits paragraphs into sentences, classifies each, and returns all results.
+
+- **`analyze_sentence_file()`**  
+  Like `handle_file_sentence()`—analyzes sentences in uploaded files.
+---
+## for image_classifier
+
+- **`Classify_Image_router()`** – Handles image classification requests by routing and coordinating preprocessing and inference.
+- **`classify_image()`** – Performs AI vs human image classification using the loaded model.
+- **`load_model()`** – Loads the pretrained model from Hugging Face at server startup.
+- **`preprocess_image()`** – Applies all required preprocessing steps to the input image.
+
+> Note: While many functions mirror those in the text classifier, the image classifier primarily uses TensorFlow rather than PyTorch.
+
+[🔙 Back to Main README](../README.md)

docs/nestjs_integration.md

@@ -0,0 +1,83 @@
+# Nestjs + fastapi
+
+You can easily call this API from a NestJS microservice.
+
+**.env**
+```env
+FASTAPI_BASE_URL=http://localhost:8000
+SECRET_TOKEN=your_secret_token_here
+```
+
+**fastapi.service.ts**
+
+```typescript
+import { Injectable } from "@nestjs/common";
+import { HttpService } from "@nestjs/axios";
+import { ConfigService } from "@nestjs/config";
+import { firstValueFrom } from "rxjs";
+
+@Injectable()
+export class FastAPIService {
+  constructor(
+    private http: HttpService,
+    private config: ConfigService,
+  ) {}
+
+  async analyzeText(text: string) {
+    const url = `${this.config.get("FASTAPI_BASE_URL")}/text/analyse`;
+    const token = this.config.get("SECRET_TOKEN");
+
+    const response = await firstValueFrom(
+      this.http.post(
+        url,
+        { text },
+        {
+          headers: {
+            Authorization: `Bearer ${token}`,
+          },
+        },
+      ),
+    );
+
+    return response.data;
+  }
+}
+```
+
+**app.module.ts**
+```typescript
+import { Module } from "@nestjs/common";
+import { ConfigModule } from "@nestjs/config";
+import { HttpModule } from "@nestjs/axios";
+import { AppController } from "./app.controller";
+import { FastAPIService } from "./fastapi.service";
+
+@Module({
+  imports: [ConfigModule.forRoot(), HttpModule],
+  controllers: [AppController],
+  providers: [FastAPIService],
+})
+export class AppModule {}
+```
+
+**app.controller.ts**
+```typescript
+import { Body, Controller, Post, Get } from '@nestjs/common';
+import { FastAPIService } from './fastapi.service';
+
+@Controller()
+export class AppController {
+  constructor(private readonly fastapiService: FastAPIService) {}
+
+  @Post('analyze-text')
+  async callFastAPI(@Body('text') text: string) {
+    return this.fastapiService.analyzeText(text);
+  }
+
+  @Get()
+  getHello(): string {
+    return 'NestJS is connected to FastAPI';
+  }
+}
+```
+[🔙 Back to Main README](../README.md)

docs/security.md

@@ -0,0 +1,10 @@
+# Security: Bearer Token Auth
+
+All endpoints require authentication via Bearer token:
+
+- Set `SECRET_TOKEN` in `.env`
+- Add header: `Authorization: Bearer <SECRET_TOKEN>`
+
+Unauthorized requests receive `403 Forbidden`.
+
+[🔙 Back to Main README](../README.md)

docs/setup.md

@@ -0,0 +1,24 @@
+# Setup & Installation
+
+## 1. Clone the Repository
+```bash
+git clone https://github.com/cyberalertnepal/aiapi
+cd aiapi
+```
+
+## 2. Install Dependencies
+```bash
+pip install -r requirements.txt
+```
+
+## 3. Configure Environment
+Create a `.env` file:
+```env
+SECRET_TOKEN=your_secret_token_here
+```
+
+## 4. Run the API
+```bash
+uvicorn app:app --host 0.0.0.0 --port 8000
+```
+[🔙 Back to Main README](../README.md)

docs/status_code.md

@@ -0,0 +1,68 @@
+# Error Codes Reference
+
+## 🔹 Summary Table
+
+| Code | Message                                               | Description                                |
+| ---- | ----------------------------------------------------- | ------------------------------------------ |
+| 400  | Text must contain at least two words                  | Input text too short                       |
+| 400  | Text should be less than 10,000 characters            | Input text too long                        |
+| 404  | The file is empty or only contains whitespace         | File has no usable content                 |
+| 404  | Invalid file type. Only .docx, .pdf, and .txt allowed | Unsupported file format                    |
+| 403  | Invalid or expired token                              | Authentication token is invalid or expired |
+| 413  | Text must contain at least two words                  | Text too short (alternative condition)     |
+| 413  | Text must be less than 10,000 characters              | Text too long (alternative condition)      |
+| 413  | The image error (preprocessing)                       | Image size/content issue                   |
+| 500  | Error processing the file                             | Internal server error while processing     |
+
+---
+
+## 🔍 Error Details
+
+### `400` - Bad Request
+
+- **Text must contain at least two words**  
+  The input text field is too short. Submit at least two words to proceed.
+
+- **Text should be less than 10,000 characters**  
+  Input text exceeds the maximum allowed character limit. Consider truncating or summarizing the content.
+
+---
+
+### `404` - Not Found
+
+- **The file is empty or only contains whitespace**  
+  The uploaded file is invalid due to lack of meaningful content. Ensure the file has readable, non-empty text.
+
+- **Invalid file type. Only .docx, .pdf, and .txt are allowed**  
+  The file format is not supported. Convert the file to one of the allowed formats before uploading.
+
+---
+
+### `403` - Forbidden
+
+- **Invalid or expired token**  
+  Your access token is either expired or incorrect. Try logging in again or refreshing the token.
+
+---
+
+### `413` - Payload Too Large
+
+- **Text must contain at least two words**  
+  The text payload is too small or malformed under a large upload context. Add more content.
+
+- **Text must be less than 10,000 characters**  
+  The payload exceeds the allowed character limit for a single request. Break it into smaller chunks if needed.
+
+- **The image error**  
+  The uploaded image is too large or corrupted. Try resizing or compressing it before retrying.
+
+---
+
+### `500` - Internal Server Error
+
+- **Error processing the file**  
+  An unexpected server-side failure occurred during file analysis. Retry later or contact support if persistent.
+
+---
+
+> 📌 **Note:** Always validate inputs, check token status, and follow file guidelines before making requests.

docs/structure.md

@@ -0,0 +1,74 @@
+## 🏗️ Project Structure
+
+```bash
+AI-Checker/
+│
+├── app.py                  # Main FastAPI entry point
+├── config.py               # Configuration settings
+├── Dockerfile              # Docker build script
+├── Procfile                # Deployment entry for platforms like Heroku/Railway
+├── requirements.txt        # Python dependency list
+├── README.md               # Main project overview 📘
+│
+├── features/               # Core AI content detection modules
+│   ├── image_classifier/           # Classifies AI vs Real images
+│   │   ├── controller.py
+│   │   ├── model_loader.py
+│   │   └── preprocess.py
+│   ├── image_edit_detector/       # Detects tampered or edited images
+│   ├── nepali_text_classifier/    # Classifies Nepali text as AI or Human
+│   │   ├── controller.py
+│   │   ├── inferencer.py
+│   │   ├── model_loader.py
+│   │   └── preprocess.py
+│   └── text_classifier/           # Classifies English text as AI or Human
+│       ├── controller.py
+│       ├── inferencer.py
+│       ├── model_loader.py
+│       └── preprocess.py
+│
+├── docs/                   # Internal documentation and API references
+│   ├── api_endpoints.md
+│   ├── deployment.md
+│   ├── detector/
+│   │   ├── ELA.md
+│   │   ├── fft.md
+│   │   ├── meta.md
+│   │   └── note-for-backend.md
+│   ├── features/
+│   │   ├── image_classifier.md
+│   │   ├── nepali_text_classifier.md
+│   │   └── text_classifier.md
+│   ├── functions.md
+│   ├── nestjs_integration.md
+│   ├── security.md
+│   ├── setup.md
+│   └── structure.md
+│
+├── IMG_Models/             # Stored model weights
+│   └── latest-my_cnn_model.h5
+│
+├── notebooks/              # Experimental/debug Jupyter notebooks
+├── static/                 # Static files (e.g., UI assets, test inputs)
+└── test.md                 # Test usage notes
+```
+
+### 🌟 Key Files and Their Roles
+
+- **`app.py`**: Entry point initializing FastAPI app and routes.
+- **`Procfile`**: Tells Railway (or similar platforms) how to run the program.
+- **`requirements.txt`**: Tracks all Python dependencies for the project.
+- **`__init__.py`**: Package initializer for the root module and submodules.
+- **`features/text_classifier/`**
+  - **`controller.py`**: Handles logic between routes and the model.
+  - **`inferencer.py`**: Runs inference and returns predictions as well as file system
+    utilities.
+- **`features/NP/`**
+  - **`controller.py`**: Handles logic between routes and the model.
+  - **`inferencer.py`**: Runs inference and returns predictions as well as file system
+    utilities.
+  - **`model_loader.py`**: Loads the ML model and tokenizer.
+  - **`preprocess.py`**: Prepares input text for the model.
+  - **`routes.py`**: Defines API routes for text classification.
+
+[🔙 Back to Main README](../README.md)

features/ai_human_image_classifier/controller.py

@@ -0,0 +1,35 @@
+from typing import IO
+from preprocessor import preprocessor
+from inferencer import inferencer
+
+class ClassificationController:
+    """
+    Controller to handle the image classification logic.
+    """
+    def classify_image(self, image_file: IO) -> dict:
+        """
+        Orchestrates the classification of a single image file.
+
+        Args:
+            image_file (IO): The image file to classify.
+
+        Returns:
+            dict: The classification result.
+        """
+        try:
+            # Step 1: Preprocess the image
+            image_tensor = preprocessor.process(image_file)
+
+            # Step 2: Perform inference
+            result = inferencer.predict(image_tensor)
+
+            return result
+        except ValueError as e:
+            # Handle specific errors like invalid images
+            return {"error": str(e)}
+        except Exception as e:
+            # Handle unexpected errors
+            print(f"An unexpected error occurred: {e}")
+            return {"error": "An internal error occurred during classification."}
+
+controller = ClassificationController()

features/ai_human_image_classifier/inferencer.py

@@ -0,0 +1,48 @@
+import torch
+import numpy as np
+from model_loader import models
+
+class Inferencer:
+
+    def __init__(self):
+        self.clip_model = models.clip_model
+        self.svm_model = models.svm_model
+
+    @torch.no_grad()
+    def predict(self, image_tensor:torch.Tensor) -> dict:
+        """
+        Takes a preprocessed image tensor and returns the classification result.
+
+        Args:
+            image_tensor (torch.Tensor): The preprocessed image tensor.
+
+        Returns:
+            dict: A dictionary containing the classification label and confidence score.
+        """
+
+        image_features = self.clip_model.encode_image(image_tensor)
+        image_features_np = image_features.cpu().numpy()
+
+        prediction = self.svm_model.predict(image_features_np)[0]
+
+        if hasattr(self.svm_model, "predict_proba"):
+            # If yes, use predict_proba for a true confidence score
+            confidence_scores = self.svm_model.predict_proba(image_features_np)[0]
+            confidence = float(np.max(confidence_scores))
+        else:
+            # If no, use decision_function as a fallback confidence measure.
+            # The absolute value of the decision function score indicates confidence.
+            # We can apply a sigmoid function to scale it to a [0, 1] range for consistency.
+            decision_score = self.svm_model.decision_function(image_features_np)[0]
+            confidence = 1 / (1 + np.exp(-np.abs(decision_score)))
+            confidence = float(confidence)
+
+        label_map = {0: 'real', 1: 'fake'}
+        classification_label = label_map.get(prediction, "unknown")
+
+        return {
+            "classification": classification_label,
+            "confidence": confidence
+        }
+
+inferencer = Inferencer()

features/ai_human_image_classifier/main.py

@@ -0,0 +1,27 @@
+from fastapi import FastAPI
+from routes import router as api_router
+
+# Initialize the FastAPI app
+app = FastAPI(
+    title="Real vs. Fake Image Classification API",
+    description="An API to classify images as real or fake using OpenAI's CLIP and an SVM model.",
+    version="1.0.0"
+)
+
+# Include the API router
+# All routes defined in routes.py will be available under the /api prefix
+app.include_router(api_router, prefix="/api", tags=["Classification"])
+
+@app.get("/", tags=["Root"])
+async def read_root():
+    """
+    A simple root endpoint to confirm the API is running.
+    """
+    return {"message": "Welcome to the Image Classification API. Go to /docs for the API documentation."}
+
+
+# To run this application:
+# 1. Make sure you have all dependencies from requirements.txt installed.
+# 2. Make sure the 'svm_model.joblib' file is in the same directory.
+# 3. Run the following command in your terminal:
+#    uvicorn main:app --reload

features/ai_human_image_classifier/model_loader.py

@@ -0,0 +1,80 @@
+import clip
+import torch
+import joblib
+from pathlib import Path
+from huggingface_hub import hf_hub_download
+
+class ModelLoader:
+    """
+    A class to load and hold the machine learning models.
+    This ensures that models are loaded only once.
+    """
+    def __init__(self, clip_model_name: str, svm_repo_id: str, svm_filename: str):
+        """
+        Initializes the ModelLoader and loads the models.
+
+        Args:
+            clip_model_name (str): The name of the CLIP model to load (e.g., 'ViT-L/14').
+            svm_repo_id (str): The repository ID on Hugging Face (e.g., 'rhnsa/ai_human_image_detector').
+            svm_filename (str): The name of the model file in the repository (e.g., 'model.joblib').
+        """
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        print(f"Using device: {self.device}")
+
+        self.clip_model, self.clip_preprocess = self._load_clip_model(clip_model_name)
+        self.svm_model = self._load_svm_model(repo_id=svm_repo_id, filename=svm_filename)
+        print("Models loaded successfully.")
+
+    def _load_clip_model(self, model_name: str):
+        """
+        Loads the specified CLIP model and its preprocessor.
+        
+        Args:
+            model_name (str): The name of the CLIP model.
+        
+        Returns:
+            A tuple containing the loaded CLIP model and its preprocess function.
+        """
+        try:
+            model, preprocess = clip.load(model_name, device=self.device)
+            return model, preprocess
+        except Exception as e:
+            print(f"Error loading CLIP model: {e}")
+            raise
+
+    def _load_svm_model(self, repo_id: str, filename: str):
+        """
+        Downloads and loads the SVM model from a Hugging Face Hub repository.
+
+        Args:
+            repo_id (str): The repository ID on Hugging Face.
+            filename (str): The name of the model file in the repository.
+
+        Returns:
+            The loaded SVM model object.
+        """
+        print(f"Downloading SVM model from Hugging Face repo: {repo_id}")
+        try:
+            # Download the model file from the Hub. It returns the cached path.
+            model_path = hf_hub_download(repo_id=repo_id, filename=filename)
+            print(f"SVM model downloaded to: {model_path}")
+            
+            # Load the model from the downloaded path
+            svm_model = joblib.load(model_path)
+            return svm_model
+        except Exception as e:
+            print(f"Error downloading or loading SVM model from Hugging Face: {e}")
+            raise
+
+# --- Global Model Instance ---
+# This creates a single instance of the models that can be imported by other modules.
+CLIP_MODEL_NAME = 'ViT-L/14'
+SVM_REPO_ID = 'rhnsa/ai_human_image_detector'
+SVM_FILENAME = 'svm_model_real.joblib' # The name of your model file in the Hugging Face repo
+
+# This instance will be created when the application starts.
+models = ModelLoader(
+    clip_model_name=CLIP_MODEL_NAME, 
+    svm_repo_id=SVM_REPO_ID, 
+    svm_filename=SVM_FILENAME
+)

features/ai_human_image_classifier/preprocessor.py

@@ -0,0 +1,34 @@
+from PIL import Image
+import torch
+from typing import IO
+from model_loader import models
+
+class ImagePreprocessor:
+
+    def __init__(self):
+        self.preprocess = models.clip_preprocess
+        self.device = models.device
+
+    def process(self, image_file: IO) -> torch.Tensor:
+        """
+        Opens an image file, preprocesses it, and returns it as a tensor.
+
+        Args:
+            image_file (IO): The image file object (e.g., from a file upload).
+
+        Returns:
+            torch.Tensor: The preprocessed image as a tensor, ready for the model.
+        """
+        try:
+            # Open the image from the file-like object
+            image = Image.open(image_file).convert("RGB")
+        except Exception as e:
+            print(f"Error opening image: {e}")
+            # You might want to raise a custom exception here
+            raise ValueError("Invalid or corrupted image file.")
+
+        # Apply the CLIP preprocessing transformations and move to the correct device
+        image_tensor = self.preprocess(image).unsqueeze(0).to(self.device)
+        return image_tensor
+    
+preprocessor = ImagePreprocessor()

features/ai_human_image_classifier/routes.py

@@ -0,0 +1,44 @@
+from fastapi import APIRouter, File, UploadFile, HTTPException, status
+from fastapi.responses import JSONResponse
+from controller import controller
+
+from fastapi import Request, Depends
+from fastapi.security import HTTPBearer
+from slowapi import Limiter
+from slowapi.util import get_remote_address
+
+
+router = APIRouter()
+limiter = Limiter(key_func=get_remote_address)
+security = HTTPBearer()
+# Create an API router
+router = APIRouter()
+
+@router.post("/classify", summary="Classify an image as Real or Fake")
+async def classify_image_endpoint(image: UploadFile = File(...)):
+    """
+    Accepts an image file and classifies it as 'real' or 'fake'.
+
+    - **image**: The image file to be classified (e.g., JPEG, PNG).
+
+    Returns a JSON object with the classification and a confidence score.
+    """
+    # Check for a valid image content type
+    if not image.content_type.startswith("image/"):
+        raise HTTPException(
+            status_code=status.HTTP_415_UNSUPPORTED_MEDIA_TYPE,
+            detail="Unsupported file type. Please upload an image (e.g., JPEG, PNG)."
+        )
+
+    # The controller expects a file-like object, which `image.file` provides
+    result = controller.classify_image(image.file)
+
+    if "error" in result:
+        # If the controller returned an error, forward it as an HTTP exception
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=result["error"]
+        )
+    
+    return JSONResponse(content=result, status_code=status.HTTP_200_OK)
+

features/image_classifier/controller.py

@@ -0,0 +1,16 @@
+from fastapi import HTTPException, File, UploadFile
+from .preprocess import preprocess_image
+from .inferencer import classify_image
+
+
+async def Classify_Image_router(file: UploadFile = File(...)):
+    try:
+        image_array = preprocess_image(file)
+        try:
+            result = classify_image(image_array)
+            return result
+        except:
+            raise HTTPException(status_code=423, detail="something went wrong")
+
+    except Exception as e:
+        raise HTTPException(status_code=413, detail=str(e))

features/image_classifier/inferencer.py

@@ -0,0 +1,42 @@
+import numpy as np
+from .model_loader import get_model
+
+# Thresholds
+AI_THRESHOLD = 0.55
+HUMAN_THRESHOLD = 0.45
+
+
+def classify_image(image_array: np.ndarray) -> dict:
+    try:
+        model = get_model()
+        predictions = model.predict(image_array)
+
+        if predictions.ndim != 2 or predictions.shape[1] != 1:
+            raise ValueError(
+                "Model output shape is invalid. Expected shape: (batch, 1)"
+            )
+
+        ai_conf = float(np.clip(predictions[0][0], 0.0, 1.0))
+        human_conf = 1.0 - ai_conf
+
+        # Classification logic
+        if ai_conf > AI_THRESHOLD:
+            label = "AI Generated"
+        elif ai_conf < HUMAN_THRESHOLD:
+            label = "Human Generated"
+        else:
+            label = "Uncertain (Maybe AI)"
+
+        return {
+            "label": label,
+            "ai_confidence": round(ai_conf * 100, 2),
+            "human_confidence": round(human_conf * 100, 2),
+        }
+
+    except Exception as e:
+        return {
+            "error": str(e),
+            "label": "Classification Failed",
+            "ai_confidence": None,
+            "human_confidence": None,
+        }

features/image_classifier/model_loader.py

@@ -0,0 +1,58 @@
+import os
+import shutil
+import logging
+import tensorflow as tf
+from tensorflow.keras.layers import Layer
+from huggingface_hub import snapshot_download
+
+# Model config
+REPO_ID = "can-org/AI-VS-HUMAN-IMAGE-classifier"
+MODEL_DIR = "./IMG_Models"
+WEIGHTS_PATH = os.path.join(MODEL_DIR, "latest-my_cnn_model.h5")
+
+# Device info (for logging)
+gpus = tf.config.list_physical_devices("GPU")
+device = "cuda" if gpus else "cpu"
+
+# Global model reference
+_model_img = None
+
+# Custom layer used in the model
+class Cast(Layer):
+    def call(self, inputs):
+        return tf.cast(inputs, tf.float32)
+
+def warmup():
+    global _model_img
+    download_model_repo()
+    _model_img = load_model()
+    logging.info("Image model is ready.")
+
+def download_model_repo():
+    if os.path.exists(MODEL_DIR) and os.path.isdir(MODEL_DIR):
+        logging.info("Image model already exists, skipping download.")
+        return
+    snapshot_path = snapshot_download(repo_id=REPO_ID)
+    os.makedirs(MODEL_DIR, exist_ok=True)
+    shutil.copytree(snapshot_path, MODEL_DIR, dirs_exist_ok=True)
+
+def load_model():
+    global _model_img
+    if _model_img is not None:
+        return _model_img
+
+    print(f"{'GPU detected' if device == 'cuda' else 'No GPU detected'}, loading model on {device.upper()}.")
+
+    _model_img = tf.keras.models.load_model(
+        WEIGHTS_PATH, custom_objects={"Cast": Cast}
+    )
+    print("Model input shape:", _model_img.input_shape)
+    return _model_img
+
+def get_model():
+    global _model_img
+    if _model_img is None:
+        download_model_repo()
+        _model_img = load_model()
+    return _model_img
+

features/image_classifier/preprocess.py

@@ -0,0 +1,26 @@
+import numpy as np
+import cv2
+from fastapi import HTTPException
+
+
+def preprocess_image(file):
+    try:
+        file.file.seek(0)
+        image_bytes = file.file.read()
+        nparr = np.frombuffer(image_bytes, np.uint8)
+        img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+        if img is None:
+            raise HTTPException(status_code=500, detail="Could not decode image.")
+
+        img = cv2.resize(img, (299, 299))
+        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+        img = img / 255.0
+        img = np.expand_dims(img, axis=0).astype(np.float32)
+        return img
+
+    except HTTPException:
+        raise  # Re-raise already defined HTTP errors
+    except Exception as e:
+        raise HTTPException(
+            status_code=500, detail=f"Image preprocessing failed: {str(e)}"
+        )

features/image_classifier/routes.py

@@ -0,0 +1,26 @@
+from slowapi import Limiter
+from config import ACCESS_RATE
+from fastapi import APIRouter, File, Request, Depends, HTTPException, UploadFile
+from fastapi.security import HTTPBearer
+from slowapi import Limiter
+from slowapi.util import get_remote_address
+from .controller import Classify_Image_router
+router = APIRouter()
+limiter = Limiter(key_func=get_remote_address)
+security = HTTPBearer()
+
+@router.post("/analyse")
+@limiter.limit(ACCESS_RATE)
+async def analyse(
+    request: Request,
+    file: UploadFile = File(...),
+    token: str = Depends(security)
+):
+    result = await Classify_Image_router(file)  # await the async function
+    return result
+
+@router.get("/health")
+@limiter.limit(ACCESS_RATE)
+def health(request: Request):
+    return {"status": "ok"}
+

features/image_edit_detector/controller.py

@@ -0,0 +1,49 @@
+from PIL import Image
+import io
+from io import BytesIO
+from .detectors.fft import run_fft
+from .detectors.metadata import run_metadata
+from .detectors.ela import run_ela
+from .preprocess import preprocess_image
+from fastapi import HTTPException,status,Depends
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+security=HTTPBearer()
+import os
+async def process_image_ela(image_bytes: bytes, quality: int=90):
+    image = Image.open(io.BytesIO(image_bytes))
+
+    if image.mode != "RGB":
+        image = image.convert("RGB")
+
+    compressed_image = preprocess_image(image, quality)
+    ela_result = run_ela(compressed_image, quality)
+
+    return {
+        "is_edited": ela_result,
+        "ela_score": ela_result
+    }
+
+async def process_fft_image(image_bytes: bytes,threshold:float=0.95) -> dict:
+    image = Image.open(BytesIO(image_bytes)).convert("RGB")
+    result = run_fft(image,threshold)
+    return {"edited": bool(result)}
+
+
+async def process_meta_image(image_bytes: bytes) -> dict:
+    try:
+        result = run_metadata(image_bytes)
+        return {"source": result}  # e.g. "edited", "phone_capture", "unknown"
+    except Exception as e:
+        # Handle errors gracefully, return useful message or raise HTTPException if preferred
+        return {"error": str(e)}
+
+
+async def verify_token(credentials: HTTPAuthorizationCredentials = Depends(security)):
+    token = credentials.credentials
+    expected_token = os.getenv("MY_SECRET_TOKEN")
+    if token != expected_token:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Invalid or expired token"
+        )
+    return token

features/image_edit_detector/detectors/ela.py

@@ -0,0 +1,32 @@
+from PIL import Image, ImageChops, ImageEnhance
+import io
+
+
+def run_ela(image: Image.Image, quality: int = 90, threshold: int = 15) -> bool:
+    """
+    Perform Error Level Analysis to detect image manipulation.
+
+    Parameters:
+        image (PIL.Image): Input image (should be RGB).
+        quality (int): JPEG compression quality for ELA.
+        threshold (int): Maximum pixel difference threshold to classify as edited.
+
+    Returns:
+        bool: True if image appears edited, False otherwise.
+    """
+
+    # Recompress the image into JPEG format in memory
+    buffer = io.BytesIO()
+    image.save(buffer, format="JPEG", quality=quality)
+    buffer.seek(0)
+    recompressed = Image.open(buffer)
+
+    # Compute the pixel-wise difference
+    diff = ImageChops.difference(image, recompressed)
+    extrema = diff.getextrema()
+    max_diff = max([ex[1] for ex in extrema])
+
+    # Enhance difference image for debug (not returned)
+    _ = ImageEnhance.Brightness(diff).enhance(10)
+
+    return max_diff > threshold

features/image_edit_detector/detectors/fft.py

@@ -0,0 +1,40 @@
+import numpy as np
+from PIL import Image
+from scipy.fft import fft2, fftshift
+
+
+def run_fft(image: Image.Image, threshold: float = 0.92) -> bool:
+    """
+    Detects potential image manipulation or generation using FFT-based high-frequency analysis.
+
+    Parameters:
+        image (PIL.Image.Image): The input image.
+        threshold (float): Proportion of high-frequency components above which the image is flagged.
+
+    Returns:
+        bool: True if the image is likely AI-generated or manipulated, False otherwise.
+    """
+    gray_image = image.convert("L")
+
+    resized_image = gray_image.resize((512, 512))
+
+
+    image_array = np.array(resized_image)
+
+    fft_result = fft2(image_array)
+
+    fft_shifted = fftshift(fft_result)
+
+    magnitude_spectrum = np.abs(fft_shifted)
+    max_magnitude = np.max(magnitude_spectrum)
+    if max_magnitude == 0:
+        return False  # Avoid division by zero if image is blank
+    normalized_spectrum = magnitude_spectrum / max_magnitude
+
+    high_freq_mask = normalized_spectrum > 0.5
+
+    high_freq_ratio = np.sum(high_freq_mask) / normalized_spectrum.size
+
+    is_fake = high_freq_ratio > threshold
+    return is_fake
+

features/image_edit_detector/detectors/metadata.py

@@ -0,0 +1,82 @@
+from PIL import Image, UnidentifiedImageError
+import io
+
+# Common AI metadata identifiers in image files.
+AI_INDICATORS = [
+    b'c2pa', b'claim_generator', b'claim_generator_info',
+    b'created_software_agent', b'actions.v2', b'assertions',
+    b'urn:c2pa', b'jumd', b'jumb', b'jumdcbor', b'jumdc2ma',
+    b'jumdc2as', b'jumdc2cl', b'cbor', b'convertedsfwareagent',b'c2pa.version', 
+    b'c2pa.assertions', b'c2pa.actions',
+    b'c2pa.thumbnail', b'c2pa.signature', b'c2pa.manifest',
+    b'c2pa.manifest_store', b'c2pa.ingredient', b'c2pa.parent',
+    b'c2pa.provenance', b'c2pa.claim', b'c2pa.hash', b'c2pa.authority',
+    b'jumdc2pn', b'jumdrefs', b'jumdver', b'jumdmeta',
+    
+    
+   'midjourney'.encode('utf-8'),
+   'stable-diffusion'.encode('utf-8'),
+   'stable diffusion'.encode('utf-8'),
+   'stable_diffusion'.encode('utf-8'),
+   'artbreeder'.encode('utf-8'),
+   'runwayml'.encode('utf-8'),
+   'remix.ai'.encode('utf-8'),
+   'firefly'.encode('utf-8'),
+   'adobe_firefly'.encode('utf-8'),
+
+    # OpenAI / DALL·E indicators (all encoded to bytes)
+    'openai'.encode('utf-8'),
+    'dalle'.encode('utf-8'),
+    'dalle2'.encode('utf-8'),
+    'DALL-E'.encode('utf-8'),
+    'DALL·E'.encode('utf-8'),
+    'created_by: openai'.encode('utf-8'),
+    'tool: dalle'.encode('utf-8'),
+    'tool: dalle2'.encode('utf-8'),
+    'creator: openai'.encode('utf-8'),
+    'creator: dalle'.encode('utf-8'),
+    'openai.com'.encode('utf-8'),
+    'api.openai.com'.encode('utf-8'),
+    'openai_model'.encode('utf-8'),
+    'openai_gpt'.encode('utf-8'),
+    
+    #Further possible AI-Generation Indicators
+    'generated_by'.encode('utf-8'),
+    'model_id'.encode('utf-8'),
+    'model_version'.encode('utf-8'),
+    'model_info'.encode('utf-8'),
+    'tool_name'.encode('utf-8'),
+    'tool_creator'.encode('utf-8'),
+    'tool_version'.encode('utf-8'),
+    'model_signature'.encode('utf-8'),
+    'ai_model'.encode('utf-8'),
+    'ai_tool'.encode('utf-8'),
+    'generator'.encode('utf-8'),
+    'generated_by_ai'.encode('utf-8'),
+    'ai_generated'.encode('utf-8'),
+    'ai_art'.encode('utf-8')
+    ]
+
+
+def run_metadata(image_bytes: bytes) -> str:
+    try:
+        img = Image.open(io.BytesIO(image_bytes))
+        img.load()
+
+        exif = img.getexif()
+        software = str(exif.get(305, "")).strip()
+
+        suspicious_editors = ["Photoshop", "GIMP", "Snapseed", "Pixlr", "VSCO", "Editor", "Adobe", "Luminar"]
+
+        if any(editor.lower() in software.lower() for editor in suspicious_editors):
+            return "edited"
+
+        if any(indicator in image_bytes for indicator in AI_INDICATORS):
+            return "ai_generated"
+
+        return "undetermined"
+
+    except UnidentifiedImageError:
+        return "error: invalid image format"
+    except Exception as e:
+        return f"error: {str(e)}"

features/image_edit_detector/preprocess.py

@@ -0,0 +1,9 @@
+from PIL import Image
+import io
+
+def preprocess_image(img: Image.Image, quality: int) -> Image.Image:
+    buffer = io.BytesIO()
+    img.save(buffer, format="JPEG", quality=quality)
+    buffer.seek(0)
+    return Image.open(buffer)
+

features/image_edit_detector/routes.py

@@ -0,0 +1,53 @@
+from slowapi import Limiter
+from config import ACCESS_RATE
+from fastapi import APIRouter, File, Request, Depends, HTTPException, UploadFile
+from fastapi.security import HTTPBearer
+from slowapi import Limiter
+from slowapi.util import get_remote_address
+from io import BytesIO
+from .controller import process_image_ela , verify_token,process_fft_image, process_meta_image
+import requests
+router = APIRouter()
+limiter = Limiter(key_func=get_remote_address)
+security = HTTPBearer()
+
+
+
+@router.post("/ela")
+@limiter.limit(ACCESS_RATE)
+async def detect_ela(request:Request,file: UploadFile = File(...), quality: int = 90 ,token: str = Depends(verify_token)):
+    # Check file extension
+    allowed_types = ["image/jpeg", "image/png"]
+
+    if file.content_type not in allowed_types:
+        raise HTTPException(
+            status_code=400,
+            detail="Unsupported file type. Only JPEG and PNG images are allowed."
+        )
+    
+    content = await file.read()
+    result = await process_image_ela(content, quality)
+    return result
+
+@router.post("/fft")
+@limiter.limit(ACCESS_RATE)
+async def detect_fft(request:Request,file:UploadFile =File(...),threshold:float=0.95,token:str=Depends(verify_token)):
+    if file.content_type not in ["image/jpeg", "image/png"]:
+        raise HTTPException(status_code=400, detail="Unsupported image type.")
+    
+    content = await file.read()
+    result = await process_fft_image(content,threshold)
+    return result
+
+@router.post("/meta")
+@limiter.limit(ACCESS_RATE)
+async def detect_meta(request:Request,file:UploadFile=File(...),token:str=Depends(verify_token)):
+    if file.content_type not in ["image/jpeg", "image/png"]:
+        raise HTTPException(status_code=400, detail="Unsupported image type.")
+    content = await file.read()    
+    result = await process_meta_image(content)
+    return result
+@router.post("/health")
+@limiter.limit(ACCESS_RATE)
+def heath(request:Request):
+    return {"status":"ok"}

features/nepali_text_classifier/controller.py

@@ -0,0 +1,130 @@
+import asyncio
+from io import BytesIO
+from fastapi import HTTPException, UploadFile, status, Depends
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+import os
+from features.nepali_text_classifier.inferencer import classify_text
+from  features.nepali_text_classifier.preprocess import *
+import re
+
+security = HTTPBearer()
+
+def contains_english(text: str) -> bool:
+    # Remove escape characters
+    cleaned = text.replace("\n", "").replace("\t", "")
+    return bool(re.search(r'[a-zA-Z]', cleaned))
+
+
+async def verify_token(credentials: HTTPAuthorizationCredentials = Depends(security)):
+    token = credentials.credentials
+    expected_token = os.getenv("MY_SECRET_TOKEN")
+    if token != expected_token:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Invalid or expired token"
+        )
+    return token
+
+async def nepali_text_analysis(text: str):
+    end_symbol_for_NP_text(text)
+    words = text.split()
+    if len(words) < 10:
+        raise HTTPException(status_code=400, detail="Text must contain at least 10 words")
+    if len(text) > 10000:
+        raise HTTPException(status_code=413, detail="Text must be less than 10,000 characters")
+
+    result = await asyncio.to_thread(classify_text, text)
+
+    return result
+
+
+#Extract text form uploaded files(.docx,.pdf,.txt)
+async def extract_file_contents(file:UploadFile)-> str:
+    content = await file.read()
+    file_stream = BytesIO(content)
+    if file.content_type == "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
+        return parse_docx(file_stream)
+    elif file.content_type =="application/pdf":
+        return parse_pdf(file_stream)
+    elif file.content_type =="text/plain":
+        return parse_txt(file_stream)
+    else:
+        raise HTTPException(status_code=415,detail="Invalid file type. Only .docx,.pdf and .txt are allowed")
+
+async def handle_file_upload(file: UploadFile):
+    try:
+        file_contents = await extract_file_contents(file)
+        end_symbol_for_NP_text(file_contents)
+        if len(file_contents) > 10000:
+            raise HTTPException(status_code=413, detail="Text must be less than 10,000 characters")
+
+        cleaned_text = file_contents.replace("\n", " ").replace("\t", " ").strip()
+        if not cleaned_text:
+            raise HTTPException(status_code=404, detail="The file is empty or only contains whitespace.")
+        
+        result = await asyncio.to_thread(classify_text, cleaned_text)
+        return result
+    except Exception as e:
+        logging.error(f"Error processing file: {e}")
+        raise HTTPException(status_code=500, detail="Error processing the file")
+
+
+
+async def handle_sentence_level_analysis(text: str):
+    text = text.strip()
+    if len(text) > 10000:
+        raise HTTPException(status_code=413, detail="Text must be less than 10,000 characters")
+    
+    end_symbol_for_NP_text(text)
+
+    # Split text into sentences
+    sentences = [s.strip() + "।" for s in text.split("।") if s.strip()]
+
+    results = []
+    for sentence in sentences:
+        end_symbol_for_NP_text(sentence)
+        result = await asyncio.to_thread(classify_text, sentence)
+        results.append({
+            "text": sentence,
+            "result": result["label"],
+            "likelihood": result["confidence"]
+        })
+
+    return {"analysis": results}
+
+
+async def handle_file_sentence(file:UploadFile):
+    try:
+        file_contents = await extract_file_contents(file)
+        if len(file_contents) > 10000:
+            raise HTTPException(status_code=413, detail="Text must be less than 10,000 characters")
+
+        cleaned_text = file_contents.replace("\n", " ").replace("\t", " ").strip()
+        if not cleaned_text:
+            raise HTTPException(status_code=404, detail="The file is empty or only contains whitespace.")
+        # Ensure text ends with danda so last sentence is included
+
+        # Split text into sentences
+        sentences = [s.strip() + "।" for s in cleaned_text.split("।") if s.strip()]
+
+        results = []
+        for sentence in sentences:
+            end_symbol_for_NP_text(sentence)
+
+            result = await asyncio.to_thread(classify_text, sentence)
+            results.append({
+                "text": sentence,
+                "result": result["label"],
+                "likelihood": result["confidence"]
+            })
+
+        return {"analysis": results}
+
+    except Exception as e:
+        logging.error(f"Error processing file: {e}")
+        raise HTTPException(status_code=500, detail="Error processing the file")
+
+
+def classify(text: str):
+    return classify_text(text)
+

features/nepali_text_classifier/inferencer.py

@@ -0,0 +1,23 @@
+import torch
+from .model_loader import get_model_tokenizer
+import torch.nn.functional as F
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+
+def classify_text(text: str):
+    model, tokenizer = get_model_tokenizer()
+    inputs = tokenizer(text, return_tensors='pt', padding=True, truncation=True, max_length=512)
+    inputs = {k: v.to(device) for k, v in inputs.items()}
+
+    with torch.no_grad():
+        outputs = model(**inputs)
+        logits = outputs if isinstance(outputs, torch.Tensor) else outputs.logits
+        probs = F.softmax(logits, dim=1)
+        pred = torch.argmax(probs, dim=1).item()
+        prob_percent = probs[0][pred].item() * 100
+
+    return {"label": "Human" if pred == 0 else "AI", "confidence": round(prob_percent, 2)}
+
+
+

features/nepali_text_classifier/model_loader.py

@@ -0,0 +1,54 @@
+import os
+import shutil
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import logging
+from huggingface_hub import snapshot_download
+from transformers import AutoTokenizer, AutoModel
+
+# Configs
+REPO_ID = "can-org/Nepali-AI-VS-HUMAN"
+BASE_DIR = "./np_text_model"
+TOKENIZER_DIR = os.path.join(BASE_DIR, "classifier")  # <- update this to match your uploaded folder
+WEIGHTS_PATH = os.path.join(BASE_DIR, "model_95_acc.pth")  # <- change to match actual uploaded weight
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+# Define model class
+class XLMRClassifier(nn.Module):
+    def __init__(self):
+        super(XLMRClassifier, self).__init__()
+        self.bert = AutoModel.from_pretrained("xlm-roberta-base")
+        self.classifier = nn.Linear(self.bert.config.hidden_size, 2)
+
+    def forward(self, input_ids, attention_mask):
+        outputs = self.bert(input_ids=input_ids, attention_mask=attention_mask)
+        cls_output = outputs.last_hidden_state[:, 0, :]
+        return self.classifier(cls_output)
+
+# Globals for caching
+_model = None
+_tokenizer = None
+
+def download_model_repo():
+    if os.path.exists(BASE_DIR) and os.path.isdir(BASE_DIR):
+        logging.info("Model already downloaded.")
+        return
+    snapshot_path = snapshot_download(repo_id=REPO_ID)
+    os.makedirs(BASE_DIR, exist_ok=True)
+    shutil.copytree(snapshot_path, BASE_DIR, dirs_exist_ok=True)
+
+def load_model():
+    download_model_repo()
+    tokenizer = AutoTokenizer.from_pretrained(TOKENIZER_DIR)
+    model = XLMRClassifier().to(device)
+    model.load_state_dict(torch.load(WEIGHTS_PATH, map_location=device))
+    model.eval()
+    return model, tokenizer
+
+def get_model_tokenizer():
+    global _model, _tokenizer
+    if _model is None or _tokenizer is None:
+        _model, _tokenizer = load_model()
+    return _model, _tokenizer
+

features/nepali_text_classifier/preprocess.py

@@ -0,0 +1,35 @@
+# import fitz  # PyMuPDF
+import docx
+from io import BytesIO
+import logging
+from fastapi import HTTPException
+from pypdf import PdfReader  
+
+def parse_docx(file: BytesIO):
+    doc = docx.Document(file)
+    text = ""
+    for para in doc.paragraphs:
+        text += para.text + "\n"
+    return text
+
+
+def parse_pdf(file: BytesIO):
+    try:
+        doc = PdfReader(file)
+        text = ""
+        for page in doc.pages:
+            text += page.extract_text()
+        return text 
+    except Exception as e:
+        logging.error(f"Error while processing PDF: {str(e)}")
+        raise HTTPException(
+            status_code=500, detail="Error processing PDF file")
+
+def parse_txt(file: BytesIO):
+    return file.read().decode("utf-8")
+
+def end_symbol_for_NP_text(text: str) -> str:
+    text = text.strip()
+    if not text.endswith("।"):
+        text += "।"
+    return text

features/nepali_text_classifier/routes.py

@@ -0,0 +1,45 @@
+from slowapi import Limiter
+from config import ACCESS_RATE
+from .controller import handle_file_sentence, handle_sentence_level_analysis, nepali_text_analysis
+from .inferencer import classify_text
+from fastapi import APIRouter, File, Request, Depends, HTTPException, UploadFile
+from fastapi.security import HTTPBearer
+from slowapi import Limiter
+from slowapi.util import get_remote_address
+from pydantic import BaseModel
+from .controller import handle_file_upload
+router = APIRouter()
+limiter = Limiter(key_func=get_remote_address)
+security = HTTPBearer()
+
+# Input schema
+class TextInput(BaseModel):
+    text: str
+
+@router.post("/analyse")
+@limiter.limit(ACCESS_RATE)
+async def analyse(request: Request, data: TextInput, token: str = Depends(security)):
+    result = classify_text(data.text)
+    return result
+
+@router.post("/upload")
+@limiter.limit(ACCESS_RATE)
+async def upload_file(request:Request,file:UploadFile=File(...),token:str=Depends(security)):
+    return await handle_file_upload(file)
+
+@router.post("/analyse-sentences")
+@limiter.limit(ACCESS_RATE)
+async def upload_file(request:Request,data:TextInput,token:str=Depends(security)):
+    return await  handle_sentence_level_analysis(data.text)
+
+@router.post("/file-sentences-analyse")
+@limiter.limit(ACCESS_RATE)
+async def analyze_sentance_file(request: Request, file: UploadFile = File(...), token: str = Depends(security)):
+    return await handle_file_sentence(file)
+
+
+@router.get("/health")
+@limiter.limit(ACCESS_RATE)
+def health(request: Request):
+    return {"status": "ok"}
+