Update app.py

app.py

@@ -1,57 +1,47 @@
 import torch
 from transformers import GPT2LMHeadModel, GPT2TokenizerFast, GPT2Config
-from fastapi import FastAPI, HTTPException, Request
+from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
 from contextlib import asynccontextmanager
 import asyncio
 
-from slowapi import Limiter
-from slowapi.util import get_remote_address
-from slowapi.errors import RateLimitExceeded
-from fastapi.responses import JSONResponse
+# FastAPI app instance
+app = FastAPI()
 
-# 🌐 Rate limiter for abuse prevention
-limiter = Limiter(key_func=get_remote_address)
+# Global model and tokenizer variables
+model, tokenizer = None, None
 
-# 🚀 FastAPI app instance
-app = FastAPI(lifespan=lambda app: load_lifespan(app))
-app.state.limiter = limiter
-
-# 📦 Global model and tokenizer
-model = None
-tokenizer = None
-
-# 🧠 Optimize CPU usage (only 1 thread for free tier)
-torch.set_num_threads(1)
-
-# 📦 Load model/tokenizer once
+# Function to load model and tokenizer
 def load_model():
     model_path = "./Ai-Text-Detector/model"
     weights_path = "./Ai-Text-Detector/model_weights.pth"
 
     try:
-        tok = GPT2TokenizerFast.from_pretrained(model_path)
+        tokenizer = GPT2TokenizerFast.from_pretrained(model_path)
         config = GPT2Config.from_pretrained(model_path)
-        mdl = GPT2LMHeadModel(config)
-        mdl.load_state_dict(torch.load(weights_path, map_location=torch.device("cpu")))
-        mdl.eval()
+        model = GPT2LMHeadModel(config)
+        model.load_state_dict(torch.load(weights_path, map_location=torch.device("cpu")))
+        model.eval()  # Set model to evaluation mode
     except Exception as e:
         raise RuntimeError(f"Error loading model: {str(e)}")
 
-    return mdl, tok
+    return model, tokenizer
 
-# ⚙️ Load during app lifespan
+# Load model on app startup
 @asynccontextmanager
-async def load_lifespan(app: FastAPI):
+async def lifespan(app: FastAPI):
     global model, tokenizer
     model, tokenizer = load_model()
     yield
 
-# 📘 Input schema
+# Attach startup loader
+app = FastAPI(lifespan=lifespan)
+
+# Input schema
 class TextInput(BaseModel):
     text: str
 
-# 🚀 Inference function
+# Sync text classification
 def classify_text(sentence: str):
     inputs = tokenizer(sentence, return_tensors="pt", truncation=True, padding=True)
     input_ids = inputs["input_ids"]
@@ -71,28 +61,27 @@ def classify_text(sentence: str):
 
     return result, perplexity
 
-# 🛡️ Rate limit error handler
-@app.exception_handler(RateLimitExceeded)
-async def rate_limit_handler(request: Request, exc):
-    return JSONResponse(status_code=429, content={"detail": "Too many requests. Please slow down."})
-
-# 🔍 Inference endpoint with rate limiting
+# POST route to analyze text
 @app.post("/analyze")
-@limiter.limit("2/second")
 async def analyze_text(data: TextInput):
     user_input = data.text.strip()
     if not user_input:
         raise HTTPException(status_code=400, detail="Text cannot be empty")
 
+    # Run classification asynchronously to prevent blocking
     result, perplexity = await asyncio.to_thread(classify_text, user_input)
-    return {"result": result, "perplexity": round(perplexity, 2)}
+    
+    return {
+        "result": result,
+        "perplexity": round(perplexity, 2),
+    }
 
-# ✅ Health check
+# Health check route
 @app.get("/health")
 async def health_check():
     return {"status": "ok"}
 
-# ℹ️ Home
+# Simple index route
 @app.get("/")
 def index():
     return {