fixed the auth issue

config.py

@@ -26,6 +26,14 @@ class Config:
     REAL_FORGED_MODEL_REPO_ID = os.getenv("REAL_FORGED_MODEL_REPO_ID", "rhnsa/real_forged_classifier")
     REAL_FORGED_MODEL_FILENAME = os.getenv("REAL_FORGED_MODEL_FILENAME", "fft_cnn_model_78.pth")
     REAL_FORGED_MODEL_LOCAL_PATH = os.getenv("REAL_FORGED_MODEL_LOCAL_PATH", "Model/real_forged/fft_cnn_model_78.pth")
+    DOCUMENT_FORGERY_MODEL_REPO_ID = os.getenv(
+        "DOCUMENT_FORGERY_MODEL_REPO_ID",
+        IMAGE_CLASSIFIER_REPO_ID
+    )
+    DOCUMENT_FORGERY_MODEL_FILENAME = os.getenv(
+        "DOCUMENT_FORGERY_MODEL_FILENAME",
+        "features/Model/document_forgery/pixel_forgery_v3_best.pth",
+    )
     DOCUMENT_FORGERY_MODEL_PATH = os.getenv(
         "DOCUMENT_FORGERY_MODEL_PATH",
         "features/Model/document_forgery/pixel_forgery_v3_best.pth",

features/real_forged_classifier/controller.py

@@ -2,6 +2,8 @@ from typing import IO
 import io
 import numpy as np
 from PIL import Image
+from fastapi import Depends, HTTPException, status
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
 import torch
 from torchvision import transforms
 
@@ -10,6 +12,19 @@ from .inferencer import interferencer
 from .model_loader import models
 from config import Config
 
+security = HTTPBearer()
+
+
+async def verify_token(credentials: HTTPAuthorizationCredentials = Depends(security)):
+    token = credentials.credentials
+    expected_token = Config.SECRET_TOKEN
+    if token != expected_token:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Invalid or expired token",
+        )
+    return token
+
 
 class ClassificationController:
     """
@@ -52,14 +67,14 @@ class documentForger:
     def is_forged(self, document_file: IO) -> dict:
         # Ensure a document model is loaded
         if not hasattr(models, 'doc_model') or models.doc_model is None:
-            return {"error": "Document forgery model not available."}
+            return {"detail": "Document forgery model not available."}
 
         # Read file bytes
         try:
             data = document_file.read()
             img = Image.open(io.BytesIO(data)).convert('RGB')
         except Exception as e:
-            return {"error": f"Could not open document image: {e}"}
+            return {"detail": f"Could not open document image: {e}"}
 
         # Compute ELA map (same approach as the notebook)
         try:
@@ -77,7 +92,7 @@ class documentForger:
 
             ela_pil = Image.fromarray(ela_arr, mode='RGB')
         except Exception as e:
-            return {"error": f"Failed to compute ELA: {e}"}
+            return {"detail": f"Failed to compute ELA: {e}"}
 
         # Transform and run through model
         transform = transforms.Compose([

features/real_forged_classifier/model_loader.py

@@ -1,8 +1,14 @@
 from pathlib import Path
 from typing import Any
+import shutil
 from .model import FFTCNN # Import the FFT CNN architecture (package-relative)
 from config import Config
 
+try:
+    from huggingface_hub import hf_hub_download
+except Exception:
+    hf_hub_download = None
+
 
 # NOTE: EfficientNet/nn imports are done lazily when torch is available.
 ELAForgeryNet = None  # will be constructed dynamically when needed
@@ -63,7 +69,7 @@ class ModelLoader:
         else:
             print("Skipping FFT model load because PyTorch is not installed.")
 
-        # Load document forgery model (ELA CNN) from local path if present
+        # Load document forgery model (ELA CNN), downloading the checkpoint if needed.
         self.doc_model = None
         if doc_model_path is None:
             doc_model_path = Config.DOCUMENT_FORGERY_MODEL_PATH
@@ -109,22 +115,25 @@ class ModelLoader:
         if not path.exists():
             print(f"Document forgery model file not found at configured path: {path}")
 
-            # 1) Try features/Model/document_forgery/ela_cnn_model.pth relative to repo root
+            # 1) Try the configured document forgery checkpoint path relative to repo root
             repo_root = Path(__file__).resolve().parents[2]
-            candidate = repo_root / 'features' / 'Model' / 'document_forgery' / 'ela_cnn_model.pth'
+            candidate = repo_root / 'features' / 'Model' / 'document_forgery' / path.name
             if candidate.exists():
                 path = candidate
                 print(f"Found document forgery model at fallback path: {path}")
             else:
-                # 2) Search the repo for any file named ela_cnn_model.pth
-                print("Searching repository for 'ela_cnn_model.pth'...")
-                matches = list(repo_root.rglob('ela_cnn_model.pth'))
+                # 2) Search the repo for any file with the configured checkpoint name
+                print(f"Searching repository for '{path.name}'...")
+                matches = list(repo_root.rglob(path.name))
                 if matches:
                     path = matches[0]
                     print(f"Found document forgery model at: {path}")
                 else:
-                    print("Document forgery model not found in repository; skipping load.")
-                    return None
+                    try:
+                        path = self._download_document_forgery_model(path)
+                    except Exception as exc:
+                        print(f"Document forgery model not found in repository and download failed: {exc}")
+                        return None
 
         print(f"Loading document forgery model from: {path}")
         # Build the ELA model architecture lazily (requires torchvision & torch.nn)
@@ -158,6 +167,32 @@ class ModelLoader:
         model.eval()
         return model
 
+    def _download_document_forgery_model(self, target_path: Path) -> Path:
+        """Download the document forgery checkpoint into the configured local path."""
+        if hf_hub_download is None:
+            raise RuntimeError("huggingface_hub not available")
+
+        repo_id = getattr(Config, "DOCUMENT_FORGERY_MODEL_REPO_ID", Config.REAL_FORGED_MODEL_REPO_ID)
+        configured_name = getattr(Config, "DOCUMENT_FORGERY_MODEL_FILENAME", str(target_path))
+        candidate_filenames = []
+        for candidate in (configured_name, str(target_path), target_path.name):
+            if candidate and candidate not in candidate_filenames:
+                candidate_filenames.append(candidate)
+
+        last_error = None
+        for filename in candidate_filenames:
+            try:
+                print(f"Downloading document forgery model from Hugging Face repo: {repo_id} ({filename})")
+                downloaded_path = hf_hub_download(repo_id=repo_id, filename=filename, token=Config.HF_TOKEN)
+                target_path.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copy2(downloaded_path, target_path)
+                print(f"Document forgery model downloaded to: {target_path}")
+                return target_path
+            except Exception as exc:
+                last_error = exc
+
+        raise RuntimeError(f"unable to download document forgery model: {last_error}")
+
 
 # --- Global Model Instance ---
 MODEL_REPO_ID = Config.REAL_FORGED_MODEL_REPO_ID

features/real_forged_classifier/routes.py

@@ -1,14 +1,14 @@
-from fastapi import APIRouter, File, UploadFile, HTTPException, status
+from fastapi import APIRouter, File, UploadFile, HTTPException, status, Depends
 from fastapi.responses import JSONResponse
 
 # Import the controller instance and document forger
-from .controller import controller, document_forger
+from .controller import controller, document_forger, verify_token
 
 # Create an API router
 router = APIRouter()
 
 @router.post("/classify_forgery", summary="Classify an image as Real or Fake")
-async def classify_image_endpoint(image: UploadFile = File(...)):
+async def classify_image_endpoint(image: UploadFile = File(...), token: str = Depends(verify_token)):
     """
     Accepts an image file and classifies it as 'real' or 'fake'.
 
@@ -36,7 +36,7 @@ async def classify_image_endpoint(image: UploadFile = File(...)):
     return JSONResponse(content=result, status_code=status.HTTP_200_OK)
 
 @router.post("/isforged", summary="Check if the document is forged")
-async def is_forged_endpoint(file: UploadFile = File(...)):
+async def is_forged_endpoint(file: UploadFile = File(...), token: str = Depends(verify_token)):
     """Run the document forgery detector on an uploaded image file.
 
     Accepts image uploads (multipart/form-data) and returns a JSON verdict with confidence.
@@ -48,7 +48,10 @@ async def is_forged_endpoint(file: UploadFile = File(...)):
         )
 
     result = document_forger.is_forged(file.file)
-    if isinstance(result, dict) and result.get("error"):
-        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=result.get("error"))
+    if isinstance(result, dict) and (result.get("error") or result.get("detail")):
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=result.get("error") or result.get("detail"),
+        )
 
     return JSONResponse(content=result, status_code=status.HTTP_200_OK)