Update app.py

app.py

@@ -1,122 +1,69 @@
-from fastapi import FastAPI, HTTPException
-from fastapi.responses import StreamingResponse
-from fastapi.middleware.cors import CORSMiddleware
-import aiohttp
-import json
-import time
+from flask import Flask, request, jsonify
+import openai
 import os
-from pydantic import BaseModel
-from apscheduler.schedulers.background import BackgroundScheduler
 
-# Initialize FastAPI application
-app = FastAPI()
-
-# CORS settings
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# Set the OpenAI API key
-OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY", None)
-
-# Time-Limited Infinite Cache
-cache = {}
-CACHE_DURATION = 120
-
-# Function to clean up expired cache entries
-def cleanup_cache():
-    current_time = time.time()
-    for key, (value, timestamp) in list(cache.items()):
-        if current_time - timestamp > CACHE_DURATION:
-            del cache[key]
-
-# Initialize and start the scheduler
-scheduler = BackgroundScheduler()
-scheduler.add_job(cleanup_cache, 'interval', seconds=60)  # Run cleanup every 60 seconds
-scheduler.start()
-
-class StreamTextRequest(BaseModel):
-    query: str
-    history: str = "[]"
-    model: str = "gpt-3.5-turbo"  # Default model can be changed as needed
-
-@app.post("/stream_text")
-async def stream_text(request: StreamTextRequest):
-    current_time = time.time()
-    cache_key = (request.query, request.history, request.model)
-
-    # Check if the request is in the cache and not expired
-    if cache_key in cache:
-        cached_response, timestamp = cache[cache_key]
-        return StreamingResponse(iter([f"{cached_response}"]), media_type='text/event-stream')
-
-    # Define system message for OpenAI
-    system_message = """You are an AI language assistant. Your sole task is to correct the grammar, spelling, and structure of the sentences provided to you. You must not change the meaning of the sentences, and you should focus only on making them grammatically correct, concise, and clear. Do not add any additional information or provide explanations unless specifically asked. Your responses should be limited to the corrected version of the sentence."""
-
-    messages = [{'role': 'system', 'content': system_message}]
-    messages.extend(json.loads(request.history))  # Load history from the request
-    messages.append({'role': 'user', 'content': request.query})
+# Initialize Flask application
+app = Flask(__name__)
+
+# Set the base URL for the API endpoint and API key from environment variables
+openai.api_base = "https://api.pawan.krd/unfiltered/v1"
+openai.api_key = os.getenv("OPENAI_API_KEY")
+
+history = []
+first_message = True
+file_name = "Default"
+chatbot_name = "Lunar Ai"
+word_limit = 2000
+
+# Introduce the chatbot with its name
+system_message = f"You are a helpful assistant named {chatbot_name}. You only answer coding-related questions. If a non-coding related question is asked, respond with 'I am not programmed to do that.'"
+history.append({"role": "system", "content": system_message})
+
+def get_word_count(text):
+    return len(text.split())
+
+def trim_history_to_word_limit(history, word_limit):
+    total_words = sum(get_word_count(message['content']) for message in history)
+    while total_words > word_limit:
+        if history[1]['role'] == 'user':
+            removed_message = history.pop(1)
+            total_words -= get_word_count(removed_message['content'])
+        if len(history) > 1 and history[1]['role'] == 'assistant':
+            removed_message = history.pop(1)
+            total_words -= get_word_count(removed_message['content'])
+
+@app.route('/chat', methods=['POST'])
+def chat_bot():
+    global first_message, file_name
+    data = request.json
+    message = data.get('message', '')
+
+    if first_message:
+        file_name = message[:20]
+        first_message = False
+
+    history.append({"role": "user", "content": message})
+
+    try:
+        chat_completion = openai.ChatCompletion.create(
+            model="gpt-4o",
+            messages=history
+        )
+        response = chat_completion.choices[0].message.content
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
     
-    data = {'model': request.model, 'messages': messages, 'stream': True}
-
-    async def stream_response():
-        async with aiohttp.ClientSession() as session:
-            async with session.post(
-                'https://api.openai.com/v1/chat/completions',
-                headers={
-                    'Authorization': f'Bearer {OPENAI_API_KEY}',
-                    'Content-Type': 'application/json'
-                },
-                json=data
-            ) as response:
-                if response.status != 200:
-                    raise HTTPException(status_code=response.status, detail="Error fetching AI response")
-
-                response_content = ""
-                async for line in response.content:
-                    line = line.decode('utf-8').strip()
-                    if line.startswith('data:'):
-                        json_data = line[5:].strip()  # Remove 'data: ' prefix
-                        if json_data:
-                            try:
-                                parsed_data = json.loads(json_data)
-                                content = parsed_data.get("choices", [{}])[0].get("delta", {}).get("content", '')
-                                if content:
-                                    content = content.replace("\n", " ")
-                                    response_content += f"data: {content}\n\n"
-                                    yield f"data: {content}\n\n"
-                            except json.JSONDecodeError as e:
-                                print(f"Error decoding JSON: {e}")
-                                yield f"data: Error decoding JSON\n\n"
-
-                # Cache the full response
-                cache[cache_key] = (response_content, current_time)
-
-    return StreamingResponse(stream_response(), media_type='text/event-stream')
+    history.append({"role": "assistant", "content": response})
 
-# Serve static files
-from starlette.responses import FileResponse 
+    # Trim history to keep within the word limit
+    trim_history_to_word_limit(history, word_limit)
 
-@app.get("/script1.js")
-async def script1_js():
-    return FileResponse("script1.js")
-
-@app.get("/script2.js")
-async def script2_js():
-    return FileResponse("script2.js")
-
-@app.get("/styles.css")
-async def styles_css():
-    return FileResponse("styles.css")
-
-@app.get("/")
-async def read_index():
-    return FileResponse('index.html')
+    # Save to a text file
+    with open(f"{file_name}.txt", 'a', encoding='utf-8') as f:
+        f.write(f"User: {message}\n")
+        f.write(f"{chatbot_name}: {response}\n")
+    
+    return jsonify({"response": response, "history": history})
 
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7068, reload=True)
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=5000)