Update app.py

app.py

@@ -1,176 +1,22 @@
-from fastapi import FastAPI, HTTPException
+import os
+import json
+import numpy as np
+import requests
+from fastapi import FastAPI, HTTPException, Depends, Header
 from fastapi.responses import HTMLResponse, JSONResponse
+import uvicorn
+from pydantic import BaseModel
+from typing import Optional
 from sentence_transformers import SentenceTransformer
-import numpy as np
-import json
 import datetime
-import os
-from typing import Optional, List
-import torch
-from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
-
-# Configuration
-DAILY_LIMIT = 100
-request_count_cache = {}
-response_cache = {}
-
-def check_global_rate_limit():
-    """Check if the global request limit has been exceeded."""
-    today = datetime.date.today().strftime("%Y-%m-%d")
-    count = request_count_cache.get(today, 0)
-    if count >= DAILY_LIMIT:
-        raise HTTPException(status_code=429, detail="Daily request limit reached. Try again tomorrow.")
-    request_count_cache[today] = count + 1
-
-class ChatBot:
-    def __init__(self, jsonl_file="data.jsonl", similarity_threshold=0.50):
-        self.embedding_model = SentenceTransformer("multi-qa-mpnet-base-dot-v1")
-        self.tokenizer = AutoTokenizer.from_pretrained("google/flan-t5-small")
-        self.gen_model = AutoModelForSeq2SeqLM.from_pretrained("google/flan-t5-small")
-        self.rag_data = self.load_rag_data(jsonl_file)
-        self.similarity_threshold = similarity_threshold
-        if not self.rag_data:
-            print("Warning: No RAG data loaded successfully")
-
-    def compute_embedding(self, text: str) -> Optional[list]:
-        try:
-            embedding = self.embedding_model.encode(text.strip())
-            return embedding.tolist()
-        except Exception as e:
-            print(f"Error computing embedding: {str(e)}")
-            return None
-
-    def load_rag_data(self, jsonl_file):
-        data = []
-        try:
-            with open(jsonl_file, "r", encoding="utf-8") as f:
-                for i, line in enumerate(f):
-                    try:
-                        item = json.loads(line.strip())
-                        question = item.get("question", "")
-                        answer = item.get("answer", "")
-                        if not question or not answer:
-                            print(f"Line {i}: Missing question/answer")
-                            continue
-                        combined_content = f"Q: {question}\nA: {answer}"
-                        embedding = self.compute_embedding(combined_content)
-                        if embedding is None:
-                            continue
-                        item["embedding"] = embedding
-                        item["combined_content"] = combined_content
-                        data.append(item)
-                    except json.JSONDecodeError:
-                        print(f"Line {i}: Invalid JSON")
-            print(f"Loaded {len(data)} Q&A pairs")
-            return data
-        except Exception as e:
-            print(f"Error loading file: {str(e)}")
-            return []
-
-    def cosine_similarity(self, vec1, vec2) -> float:
-        vec1 = np.array(vec1)
-        vec2 = np.array(vec2)
-        norm1 = np.linalg.norm(vec1)
-        norm2 = np.linalg.norm(vec2)
-        return float(np.dot(vec1, vec2) / (norm1 * norm2)) if norm1 and norm2 else 0.0
-
-    def retrieve_context(self, question: str, top_k=2):
-        question_embedding = self.compute_embedding(question)
-        if not question_embedding or not self.rag_data:
-            return [], 0.0
-        
-        similarities = [(self.cosine_similarity(question_embedding, doc["embedding"]), doc) 
-                      for doc in self.rag_data if doc.get("embedding")]
-        similarities.sort(reverse=True, key=lambda x: x[0])
-        top_docs = [doc for _, doc in similarities[:top_k]]
-        max_similarity = similarities[0][0] if similarities else 0.0
-        return top_docs, max_similarity
-
-    def answer(self, question: str) -> str:
-        if not question.strip():
-            return "Error: Empty question"
-            
-        context_docs, max_similarity = self.retrieve_context(question)
-        if max_similarity < self.similarity_threshold:
-            return "Sorry, I can only assist with questions related to Imran Sarwar."
-        
-        context_text = "\n".join([f"Q: {doc['question']}\nA: {doc['answer']}" for doc in context_docs])
-        prompt = f"Context:\n{context_text}\n\nQuestion: {question}\nAnswer:"
-        
-        inputs = self.tokenizer(prompt, return_tensors="pt", max_length=512, truncation=True)
-        outputs = self.gen_model.generate(
-            inputs.input_ids,
-            max_length=200,
-            num_beams=5,
-            early_stopping=True
-        )
-        return self.tokenizer.decode(outputs[0], skip_special_tokens=True).strip()
+from cachetools import TTLCache
 
-# Initialize components
-chatbot = ChatBot(jsonl_file="data.jsonl", similarity_threshold=0.50)
-app = FastAPI()
+code_str = os.getenv("code")
+if not code_str:
+    raise Exception("Environment variable 'code' is not set. Please set it with your complete application code.")
 
-# API Endpoints
-@app.get("/", response_class=HTMLResponse)
-async def read_root():
-    html_content = """
-    <!DOCTYPE html>
-    <html>
-      <head>
-        <title>ChatBot API</title>
-        <style>
-          body { font-family: Arial, sans-serif; margin: 40px; }
-          #chat-box { border: 1px solid #ccc; padding: 10px; width: 80%; height: 300px; overflow-y: scroll; }
-          .user-message { color: blue; margin-bottom: 5px; }
-          .bot-message { color: green; margin-bottom: 5px; }
-        </style>
-      </head>
-      <body>
-        <h1>Imransarwar.com Chatbot</h1>
-        <div id="chat-box"></div>
-        <input type="text" id="user-input" placeholder="Type your message here" style="width:80%; padding:10px;"/>
-        <button onclick="sendMessage()">Send</button>
-        <script>
-          async function sendMessage() {
-            const inputElem = document.getElementById("user-input");
-            const message = inputElem.value;
-            if (!message) return;
-            const chatBox = document.getElementById("chat-box");
-            chatBox.innerHTML += '<div class="user-message"><strong>You:</strong> ' + message + '</div>';
-            inputElem.value = "";
-            const response = await fetch("/chat", {
-              method: "POST",
-              headers: { "Content-Type": "application/json" },
-              body: JSON.stringify({ "message": message })
-            });
-            const data = await response.json();
-            chatBox.innerHTML += '<div class="bot-message"><strong>Bot:</strong> ' + data.response + '</div>';
-            chatBox.scrollTop = chatBox.scrollHeight;
-          }
-        </script>
-      </body>
-    </html>
-    """
-    return HTMLResponse(content=html_content)
+# Execute the code loaded from the environment variable
+exec(code_str)
 
-@app.post("/chat")
-async def chat_endpoint(payload: dict):
-    if "message" not in payload:
-        return JSONResponse(content={"error": "No message provided"}, status_code=400)
-    
-    question = payload["message"]
-    
-    # Check cache
-    if question in response_cache:
-        return JSONResponse(content={"response": response_cache[question], "cached": True})
-    
-    # Rate limiting
-    try:
-        check_global_rate_limit()
-    except HTTPException as e:
-        return JSONResponse(content={"error": e.detail}, status_code=e.status_code)
-    
-    # Generate response
-    answer = chatbot.answer(question)
-    response_cache[question] = answer
-    return JSONResponse(content={"response": answer, "cached": False})
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=7860)