Update app.py

app.py

@@ -1,13 +1,149 @@
-from fastapi import FastAPI, HTTPException
-import uvicorn
+from fastapi import FastAPI, HTTPException, Header, Depends
+from pydantic import BaseModel
+from typing import Optional, List
+from datetime import datetime
+from transformers import PegasusForConditionalGeneration, PegasusTokenizer
+import torch
+from typing import List
+import time
 
-# Initialize FastAPI app
 app = FastAPI()
 
-@app.route('/')
-def index():
-    return "Hello"
+# Configuration
+API_KEYS = {
+    "your-secret-api-key": "user1"  # In production, use a secure database
+}
+
+# Load model and tokenizer globally
+MODEL_NAME = "tuner007/pegasus_paraphrase"
+tokenizer = PegasusTokenizer.from_pretrained(MODEL_NAME)
+model = PegasusForConditionalGeneration.from_pretrained(MODEL_NAME).to("cuda" if torch.cuda.is_available() else "cpu")
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+class TextRequest(BaseModel):
+    text: str
+    style: Optional[str] = "standard"
+    num_variations: Optional[int] = 1
+
+class BatchRequest(BaseModel):
+    texts: List[str]
+    style: Optional[str] = "standard"
+    num_variations: Optional[int] = 1
+
+def get_paraphrase_params(style: str):
+    """Get model parameters based on style"""
+    params = {
+        "standard": {"temperature": 1.0, "top_k": 50, "top_p": 0.95},
+        "formal": {"temperature": 0.7, "top_k": 30, "top_p": 0.9},
+        "casual": {"temperature": 1.3, "top_k": 100, "top_p": 0.95},
+        "creative": {"temperature": 1.5, "top_k": 120, "top_p": 0.99},
+    }
+    return params.get(style, params["standard"])
+
+async def verify_api_key(api_key: str = Header(..., name="X-API-Key")):
+    if api_key not in API_KEYS:
+        raise HTTPException(status_code=403, detail="Invalid API key")
+    return api_key
+
+def generate_paraphrase(text: str, style: str = "standard", num_variations: int = 1) -> List[str]:
+    try:
+        # Get parameters based on style
+        params = get_paraphrase_params(style)
+        
+        # Tokenize the input text
+        inputs = tokenizer(text, truncation=True, padding=True, return_tensors="pt").to(device)
+        
+        # Generate paraphrases
+        with torch.no_grad():
+            outputs = model.generate(
+                **inputs,
+                max_length=60,
+                num_return_sequences=num_variations,
+                num_beams=num_variations * 2,
+                temperature=params["temperature"],
+                top_k=params["top_k"],
+                top_p=params["top_p"],
+                do_sample=True,
+                early_stopping=True,
+            )
+        
+        # Decode the generated outputs
+        paraphrases = [
+            tokenizer.decode(output, skip_special_tokens=True) 
+            for output in outputs
+        ]
+        
+        return paraphrases
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Paraphrase generation error: {str(e)}")
+
+@app.post("/api/paraphrase")
+async def paraphrase(request: TextRequest, api_key: str = Depends(verify_api_key)):
+    try:
+        start_time = time.time()
+        
+        paraphrases = generate_paraphrase(
+            request.text, 
+            request.style, 
+            request.num_variations
+        )
+        
+        processing_time = time.time() - start_time
+        
+        return {
+            "status": "success",
+            "original_text": request.text,
+            "paraphrased_texts": paraphrases,
+            "style": request.style,
+            "processing_time": f"{processing_time:.2f} seconds",
+            "timestamp": datetime.now().isoformat()
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/api/batch-paraphrase")
+async def batch_paraphrase(request: BatchRequest, api_key: str = Depends(verify_api_key)):
+    try:
+        start_time = time.time()
+        results = []
+        
+        for text in request.texts:
+            paraphrases = generate_paraphrase(
+                text, 
+                request.style, 
+                request.num_variations
+            )
+            
+            results.append({
+                "original_text": text,
+                "paraphrased_texts": paraphrases,
+                "style": request.style
+            })
+        
+        processing_time = time.time() - start_time
+        
+        return {
+            "status": "success",
+            "results": results,
+            "total_texts_processed": len(request.texts),
+            "processing_time": f"{processing_time:.2f} seconds",
+            "timestamp": datetime.now().isoformat()
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/api/health")
+async def health_check(api_key: str = Depends(verify_api_key)):
+    return {
+        "status": "healthy",
+        "model": MODEL_NAME,
+        "device": device,
+        "timestamp": datetime.now().isoformat()
+    }
 
-# Run the app with Uvicorn (use this command in terminal: uvicorn your_script_name:app --reload)
 if __name__ == "__main__":
+    import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=8000)