Update app.py

app.py

@@ -1,150 +1,190 @@
-from fastapi import FastAPI, File, UploadFile, HTTPException
+from fastapi import FastAPI, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
-import tensorflow as tf
-import numpy as np
-from PIL import Image
-import io
-import uvicorn
-import tempfile
-import cv2
-
+from pydantic import BaseModel
+from sentence_transformers import SentenceTransformer, util
+import pickle
+import google.generativeai as genai
+from datetime import datetime
+from typing import Dict
+import os
+
+app = FastAPI(title="Jimma University Plagiarism API")
+
+# ====================== SAFE LIMITS ======================
+MAX_TEXT_LENGTH = 8000
+MAX_PROMPT_LENGTH = 4000
+SIMILARITY_THRESHOLD = 30.0
+# =========================================================
+
+# ====================== RATING FUNCTION ======================
+def convert_to_rating(similarity_percent: float) -> int:
+    if similarity_percent >= 80:
+        return 5
+    elif similarity_percent >= 60:
+        return 4
+    elif similarity_percent >= 40:
+        return 3
+    elif similarity_percent >= 20:
+        return 2
+    else:
+        return 1
+# ============================================================
+
+# ====================== ROOT ======================
+@app.get("/")
+def home():
+    return {"message": "Jimma University Plagiarism API is running 🚀"}
 
-# Initialize FastAPI app
-app = FastAPI(title="Plant Disease Detection API", version="1.0.0")
+@app.get("/health")
+def health():
+    return {"status": "ok"}
+# ==================================================
 
-# Add CORS middleware to allow requests from your frontend
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],  # In production, replace with your frontend URL
-    allow_credentials=True,
+    allow_origins=["*"],
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
-# Load your model
-try:
-    model = tf.keras.models.load_model("trained_modela.keras")
-except Exception as e:
-    raise RuntimeError(f"Failed to load model: {e}")
-
-# Define your class names (update with your actual classes)
-class_name = ['Apple___Apple_scab',
-    'Apple___Black_rot',
-    'Apple___Cedar_apple_rust',
-    'Apple___healthy',
-    'Blueberry___healthy',
-    'Cherry_(including_sour)___Powdery_mildew',
-    'Cherry_(including_sour)___healthy',
-    'Corn_(maize)___Cercospora_leaf_spot Gray_leaf_spot',
-    'Corn_(maize)___Common_rust_',
-    'Corn_(maize)___Northern_Leaf_Blight',
-    'Corn_(maize)___healthy',
-    'Grape___Black_rot',
-    'Grape___Esca_(Black_Measles)',
-    'Grape___Leaf_blight_(Isariopsis_Leaf_Spot)',
-    'Grape___healthy',
-    'Orange___Haunglongbing_(Citrus_greening)',
-    'Peach___Bacterial_spot',
-    'Peach___healthy',
-    'Pepper,_bell___Bacterial_spot',
-    'Pepper,_bell___healthy',
-    'Potato___Early_blight',
-    'Potato___Late_blight',
-    'Potato___healthy',
-    'Raspberry___healthy',
-    'Soybean___healthy',
-    'Squash___Powdery_mildew',
-    'Strawberry___Leaf_scorch',
-    'Strawberry___healthy',
-    'Tomato___Bacterial_spot',
-    'Tomato___Early_blight',
-    'Tomato___Late_blight',
-    'Tomato___Leaf_Mold',
-    'Tomato___Septoria_leaf_spot',
-    'Tomato___Spider_mites Two-spotted_spider_mite',
-    'Tomato___Target_Spot',
-    'Tomato___Tomato_Yellow_Leaf_Curl_Virus',
-    'Tomato___Tomato_mosaic_virus',
-    'Tomato___healthy']
+# ====================== CONFIG ======================
+GEMINI_API_KEY = os.getenv(
+    "GEMINI_API_KEY",
+    "AQ.Ab8RN6Id1IlRKgMi19Vmy7PGrY82ZxG5D34vsDOnsFOFdrRI6g"
+)
 
+MODEL_PATH = "plagiarism_sbert_model"
+EMBEDDINGS_FILE = "reference_embeddings.pkl"
+# ===================================================
 
-@app.get("/")
-async def root():
-    print("dfhkjfdshu")
-    return {"message": "Plant Disease Detection API", "version": "1.0.0"}
+# ====================== LOAD MODEL (FIXED) ======================
+if not os.path.exists(MODEL_PATH):
+    raise RuntimeError("❌ Model folder not found")
 
-@app.post("/predict")
-async def predict_disease(file: UploadFile = File(...)):
-    
-    if not file.content_type.startswith('image/'):
-            raise HTTPException(status_code=400, detail="File must be an image")
+model = SentenceTransformer(MODEL_PATH)
 
-    try:
-        # Validate file type
-        # Validate file type
-        
-        # Save uploaded file temporarily
-        with tempfile.NamedTemporaryFile(suffix=".jpeg", delete=False) as tmp:
-            temp_path = tmp.name
-            tmp.write(await file.read())
-            tmp.flush()  # Ensure data is written
-        
-        # Read image using OpenCV
-        # img = cv2.imread(temp_path)
-        # if img is None:
-        #     raise HTTPException(status_code=400, detail="Invalid image file")
-        # img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
-        
-        image = tf.keras.preprocessing.image.load_img(temp_path,target_size=(128, 128))
-        
-        input_arr = tf.keras.preprocessing.image.img_to_array(image)
-        input_arr = np.array([input_arr])  # Convert single image to batch
-
-        # Predict
-        prediction = model.predict(input_arr)
-        result_index = np.argmax(prediction)
-        confidence = float(prediction[0][result_index])
-        disease_name = class_name[result_index]
-
-        
+print("✅ SBERT model loaded")
 
-        return {
-            "success": True,
-            "disease": disease_name,
-            "confidence": confidence
-        }
+# ====================== LOAD REFERENCE DATASET ======================
+if not os.path.exists(EMBEDDINGS_FILE):
+    raise RuntimeError("❌ Reference embeddings file not found")
 
-    
-    
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Prediction error: {str(e)}")
+with open(EMBEDDINGS_FILE, "rb") as f:
+    data = pickle.load(f)
 
-@app.get("/health")
-async def health_check():
-    return {"status": "healthy"}
+ref_embeddings = data["embeddings"]
+df_ref = data["df_ref"]
 
-@app.get("/classes")
-async def get_classes():
-    """Get all available disease classes"""
-    return {"classes": class_name}
+print("✅ Reference dataset loaded")
+# ================================================================
 
-if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+# ====================== GEMINI ======================
+genai.configure(api_key=GEMINI_API_KEY)
+gemini_model = genai.GenerativeModel('gemini-2.5-flash')
 
+print("✅ System ready")
+# ===================================================
 
+# ====================== REQUEST MODEL ======================
+class PlagiarismRequest(BaseModel):
+    text: str
+    title: str = "Submitted Document"
+    student_name: str = "Unknown Student"
+    year: str = "2026"
+# ============================================================
 
+# ====================== API ======================
+@app.post("/check_plagiarism")
+async def check_plagiarism(req: PlagiarismRequest) -> Dict:
 
+    text = req.text.strip()
 
+    if len(text) < 200:
+        raise HTTPException(400, "Text too short (minimum 200 characters)")
 
+    if len(text) > MAX_TEXT_LENGTH:
+        text = text[:MAX_TEXT_LENGTH]
 
+    # ================= SBERT ENCODING =================
+    try:
+        query_embedding = model.encode(
+            text,
+            convert_to_tensor=True,
+            normalize_embeddings=True
+        )
 
+        # IMPORTANT FIX: cosine similarity stays in 0–1 range
+        cosine_scores = util.cos_sim(query_embedding, ref_embeddings)[0]
 
+        # convert to percentage properly
+        similarities = (cosine_scores * 100).cpu().numpy()
 
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Embedding error: {str(e)}")
+
+    # ================= TOP MATCH =================
+    top_idx = int(similarities.argmax())
+    top_similarity = float(similarities[top_idx])
+
+    rating = convert_to_rating(top_similarity)
+    stars = "★" * rating + "☆" * (5 - rating)
+
+    # ================= LOW RISK =================
+    if top_similarity <= SIMILARITY_THRESHOLD:
+        return {
+            "status": "low_risk",
+            "similarity_percent": round(top_similarity, 2),
+            "rating": rating,
+            "stars": stars,
+            "message": "No significant plagiarism detected."
+        }
+
+    # ================= SOURCE =================
+    row = df_ref.iloc[top_idx]
+    source_title = str(row.get("title", "Reference Project"))[:150]
+    source_student = str(row.get("student_name", "Original Student"))
+    source_year = str(row.get("year", "2023"))
 
+    category = "LOW" if top_similarity <= 30 else "MEDIUM" if top_similarity <= 70 else "HIGH"
+    emoji = "✅" if category == "LOW" else "⚖️" if category == "MEDIUM" else "❌"
 
+    # ================= GEMINI PROMPT =================
+    prompt = f"""
+You are a strict academic plagiarism supervisor at Jimma University.
 
+{emoji} {category} SIMILARITY CASE
 
+Source Title: {source_title}
+Student Name: {source_student}
+Year: {source_year}
 
+Suspicious Title: {req.title}
+Student Name: {req.student_name}
+Year: {req.year}
 
+Similarity Score: {top_similarity:.1f}%
 
+1. Conceptual Similarity:
+2. Conceptual Differences:
+3. Technology Differences:
+4. Supervisor Recommendation:
+"""
 
+    try:
+        prompt = prompt[:MAX_PROMPT_LENGTH]
+        response = gemini_model.generate_content(prompt)
+        report = response.text.strip()
+
+    except Exception as e:
+        report = f"Gemini error: {str(e)}"
+
+    return {
+        "status": "suspicious",
+        "similarity_percent": round(top_similarity, 2),
+        "rating": rating,
+        "stars": stars,
+        "most_similar_source": source_title,
+        "source_student": source_student,
+        "gemini_report": report,
+        "timestamp": datetime.now().isoformat()
+    }