feat: Added the rate limiting per route

app.py

@@ -1,47 +1,36 @@
 from fastapi import FastAPI, Request
-from contextlib import asynccontextmanager
-from features.text_classifier.routes import router as text_classifier_router
-from features.text_classifier.model_loader import warmup
 from slowapi import Limiter, _rate_limit_exceeded_handler
-from slowapi.util import get_remote_address
-from slowapi.errors import RateLimitExceeded
 from slowapi.middleware import SlowAPIMiddleware
-from config import ACCESS_RATE  # E.g., "100/minute"
-import nltk
-import requests
-
-# Warmup logic
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    warmup()
-    yield
+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 config import ACCESS_RATE
 
-# Create the limiter with a global rate from config
 limiter = Limiter(key_func=get_remote_address, default_limits=[ACCESS_RATE])
 
-# Initialize FastAPI with lifespan
-app = FastAPI(lifespan=lifespan)
+app = FastAPI()
 
-# Set limiter and exception handler
+# Set up SlowAPI
 app.state.limiter = limiter
-app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
-
-# Add SlowAPI middleware globally
+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)
 
-# Register routers
+# Include your routes
 app.include_router(text_classifier_router, prefix="/text")
 
-# Root route
 @app.get("/")
-def index():
+@limiter.limit(ACCESS_RATE)
+async def root():
     return {
-        "Message": "FastAPI is running...",
-        "Try": "/text/analyse or /text/analyse-sentences"
+        "message": "API is working",
+        "endpoints": ["/text/analyse", "/text/upload", "/text/analyse-sentences", "/text/analyse-sentance-file"]
     }
 
-# Example protected route
-@app.get("/home")
-async def homepage(request: Request):
-    return {"msg": "This is a good message"}
-

config.py

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

features/text_classifier/controller.py

@@ -23,10 +23,10 @@ async def verify_token(credentials: HTTPAuthorizationCredentials = Depends(secur
 # Text classification
 async def handle_text_analysis(text: str):
     text = text.strip()
-    if not text or len(text.split()) < 2:
+    if not text or len(text.split()) < 10:
         raise HTTPException(status_code=400, detail="Text must contain at least two words")
     if len(text) > 10000:
-        raise HTTPException(status_code=400, detail="The text should be less than 10,000 characters.")
+        raise HTTPException(status_code=413, detail="Text must be less than 10,000 characters.")
     label, perplexity, ai_likelihood = await asyncio.to_thread(classify_text, text)
     return {"result": label, "perplexity": round(perplexity, 2), "ai_likelihood": ai_likelihood}
 

features/text_classifier/routes.py

@@ -1,11 +1,19 @@
-from fastapi import APIRouter, Depends, HTTPException, UploadFile, File 
-from fastapi.security import HTTPBearer 
+from fastapi import APIRouter, Depends, HTTPException, UploadFile, File, Request
+from fastapi.security import HTTPBearer
 from pydantic import BaseModel
-from .controller import handle_text_analysis, handle_file_upload, handle_sentence_level_analysis, handle_file_sentance
-from .controller import verify_token
-
-
-
+from slowapi.util import get_remote_address
+from slowapi import Limiter
+from slowapi.errors import RateLimitExceeded
+from config import ACCESS_RATE
+from .controller import (
+    handle_text_analysis,
+    handle_file_upload,
+    handle_sentence_level_analysis,
+    handle_file_sentance,
+    verify_token
+)
+
+limiter = Limiter(key_func=get_remote_address)
 router = APIRouter()
 security = HTTPBearer()
 
@@ -13,24 +21,29 @@ class TextInput(BaseModel):
     text: str
 
 @router.post("/analyse")
-async def analyze(data: TextInput, token: str = Depends(verify_token)):
+@limiter.limit(ACCESS_RATE)
+async def analyze(request: Request, data: TextInput, token: str = Depends(verify_token)):
     return await handle_text_analysis(data.text)
 
 @router.post("/upload")
-async def upload_file(file: UploadFile = File(...), token: str = Depends(verify_token)):
+@limiter.limit(ACCESS_RATE)
+async def upload_file(request: Request, file: UploadFile = File(...), token: str = Depends(verify_token)):
     return await handle_file_upload(file)
 
 @router.post("/analyse-sentences")
-async def analyze_sentences(data: TextInput, token: str = Depends(verify_token)):
+@limiter.limit(ACCESS_RATE)
+async def analyze_sentences(request: Request, data: TextInput, token: str = Depends(verify_token)):
     if not data.text:
         raise HTTPException(status_code=400, detail="Missing 'text' in request body")
     return await handle_sentence_level_analysis(data.text)
 
 @router.post("/analyse-sentance-file")
-async def AnalyzeSentanceFile(file: UploadFile = File(...), token: str = Depends(verify_token)):
+@limiter.limit(ACCESS_RATE)
+async def analyze_sentance_file(request: Request, file: UploadFile = File(...), token: str = Depends(verify_token)):
     return await handle_file_sentance(file)
 
 @router.get("/health")
-def health():
+@limiter.limit(ACCESS_RATE)
+def health(request: Request):
     return {"status": "ok"}
 

requirements.txt

@@ -8,6 +8,6 @@ python-docx
 pydantic
 PyMuPDF
 nltk
-slowapi
 python-multipart
+slowapi