Upload 3 files

aisugg22.py

@@ -0,0 +1,75 @@
+from fastapi import FastAPI, HTTPException, UploadFile, File, Security, status
+from fastapi.security.api_key import APIKeyHeader
+from environs import Env
+import json
+
+# Importing modules from both scripts
+from coresugg import ConversationPayload as ConversationPayloadSugg, create_conversation_starter_prompt, generate_conversation_starters, NUMBER_OF_MESSAGES_FOR_CONTEXT as NUMBER_OF_MESSAGES_FOR_CONTEXT_SUGG
+from corechat import ConversationPayload as ConversationPayloadChat, get_conversation_suggestions, NUMBER_OF_MESSAGES_FOR_CONTEXT as NUMBER_OF_MESSAGES_FOR_CONTEXT_CHAT
+
+# Load environment variables
+env = Env()
+API_KEY = env.str("API_KEY", "koottu123456abcDEF")
+api_key_header = APIKeyHeader(name="X-API-KEY", auto_error=False)
+
+app = FastAPI()
+
+async def get_api_key(api_key_header: str = Security(api_key_header)):
+    if api_key_header == API_KEY:
+        return api_key_header
+    else:
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Invalid API Key")
+
+# Route from app.py
+@app.post("/integration")
+def integration(payload: ConversationPayloadSugg, api_key: str = Security(get_api_key)):
+    from_user_questions = payload.FromUserKavasQuestions[-NUMBER_OF_MESSAGES_FOR_CONTEXT_SUGG:]
+    to_user_questions = payload.ToUserKavasQuestions[-NUMBER_OF_MESSAGES_FOR_CONTEXT_SUGG:]
+    ai_prompt = create_conversation_starter_prompt(from_user_questions + to_user_questions, payload.Chatmood)
+    conversation_starters = generate_conversation_starters(ai_prompt)
+    return {"conversation_starters": conversation_starters}
+
+# Route from chatt.py
+@app.post("/chat_integration")
+def chat_integration(payload: ConversationPayloadChat, api_key: str = Security(get_api_key)):
+    last_chat_messages = payload.LastChatMessages[-NUMBER_OF_MESSAGES_FOR_CONTEXT_CHAT:]
+    suggestions = get_conversation_suggestions(last_chat_messages)
+    return {"version": "1.0.0-alpha", "suggested_responses": suggestions}
+
+# Combined upload endpoint
+@app.post("/upload")
+async def upload_file(file: UploadFile = File(...), api_key: str = Security(get_api_key)):
+    if file.content_type != 'application/json':
+        raise HTTPException(status_code=400, detail="Invalid file type. Please upload a JSON file.")
+
+    data = await file.read()
+    try:
+        json_data = json.loads(data)
+    except json.JSONDecodeError:
+        raise HTTPException(status_code=400, detail="Invalid JSON format.")
+
+    if "FromUserKavasQuestions" in json_data and "Chatmood" in json_data:
+        prompt = create_conversation_starter_prompt(
+            json_data["FromUserKavasQuestions"], 
+            json_data["Chatmood"]
+        )
+        starter_suggestion = generate_conversation_starters(prompt)
+        return {"conversation_starter": starter_suggestion}
+    elif "LastChatMessages" in json_data:
+        last_chat_messages = json_data["LastChatMessages"][-NUMBER_OF_MESSAGES_FOR_CONTEXT_CHAT:]
+        response = {
+            "version": "1.0.0-alpha",
+            "suggested_responses": get_conversation_suggestions(last_chat_messages)
+        }
+        return response
+    else:
+        raise HTTPException(status_code=400, detail="Invalid JSON structure.")
+
+
+
+
+#uvicorn app:app --reload
+
+
+
+#uvicorn aisugg22:app --reload

corechat.py

@@ -0,0 +1,105 @@
+from pydantic import BaseModel
+import openai
+from environs import Env
+from typing import List
+
+# Configuration and API Key Management
+env = Env()
+env.read_env("openai.env")
+openai.api_key = env.str("OPENAI_API_KEY")
+SYSTEM_PROMPT = env.str("SYSTEM_PROMPT", "Suggest a suitable reply for a user in a dating conversation context.")
+MODEL = env.str("MODEL", "gpt-3.5-turbo")
+NUMBER_OF_MESSAGES_FOR_CONTEXT = min(env.int("NUMBER_OF_MESSAGES_FOR_CONTEXT", 4), 10)
+AI_RESPONSE_TIMEOUT = env.int("AI_RESPONSE_TIMEOUT", 20)
+
+class LastChatMessage(BaseModel):
+    fromUser: str
+    touser: str
+
+class ConversationPayload(BaseModel):
+    fromusername: str
+    tousername: str
+    zodiansign: str
+    LastChatMessages: List[dict]
+    Chatmood: str
+
+def transform_messages(last_chat_messages):
+    t_messages = []
+    for chat in last_chat_messages:
+        if "fromUser" in chat:
+            from_user = chat['fromUser']
+            message = chat.get('touser', '')
+            t_messages.append(f"{from_user}: {message}")
+        elif "touser" in chat:
+            to_user = chat['touser']
+            message = chat.get('fromUser', '')
+            t_messages.append(f"{to_user}: {message}")
+    
+    if t_messages and "touser" in last_chat_messages[-1]:
+        latest_message = t_messages[-1]
+        latest_message = f"Q: {latest_message}"
+        t_messages[-1] = latest_message
+    
+    return t_messages
+
+def generate_system_prompt(last_chat_messages, fromusername, tousername, zodiansign=None, chatmood=None):
+    prompt = ""
+    if not last_chat_messages or ("touser" not in last_chat_messages[-1]):
+        prompt = f"Suggest a casual and friendly message for {fromusername} to start a conversation with {tousername} or continue naturally, as if talking to a good friend. Strictly avoid replying to messages from {fromusername} or answering their questions."
+    else:
+        prompt = f"Suggest a warm and friendly reply for {fromusername} to respond to the last message from {tousername}, as if responding to a dear friend. Strictly avoid replying to messages from {fromusername} or answering their questions."
+    
+    if zodiansign:
+        prompt += f" Keep in mind {tousername}'s {zodiansign} zodiac sign."
+    if chatmood:
+        prompt += f" Consider the {chatmood} mood."
+    
+    return prompt
+
+def get_conversation_suggestions(last_chat_messages):
+    fromusername = last_chat_messages[-1].get("fromusername", "")
+    tousername = last_chat_messages[-1].get("tousername", "")
+    zodiansign = last_chat_messages[-1].get("zodiansign", "")
+    chatmood = last_chat_messages[-1].get("Chatmood", "")
+    
+    messages = transform_messages(last_chat_messages)
+    
+    system_prompt = generate_system_prompt(last_chat_messages, fromusername, tousername, zodiansign, chatmood)
+    messages_final = [{"role": "system", "content": system_prompt}]
+    
+    if messages:
+        messages_final.extend([{"role": "user", "content": m} for m in messages])
+    else:
+        # If there are no messages, add a default message to ensure a response is generated
+        default_message = f"{tousername}: Hi there!"
+        messages_final.append({"role": "user", "content": default_message})
+    
+    try:
+        response = openai.ChatCompletion.create(
+            model=MODEL,
+            messages=messages_final,
+            temperature=0.7,
+            max_tokens=150,
+            n=3,
+            request_timeout=AI_RESPONSE_TIMEOUT
+        )
+        
+        formatted_replies = []
+        for idx, choice in enumerate(response.choices):
+            formatted_replies.append({
+                "type": "TEXT",
+                "body": choice.message['content'],
+                "title": f"AI Reply {idx + 1}",
+                "confidence": 1,
+            })
+        
+        return formatted_replies
+    
+    except openai.error.Timeout as e:
+        formatted_reply = [{
+            "type": "TEXT",
+            "body": "Request to the AI response generator has timed out. Please try again later.",
+            "title": "AI Response Error",
+            "confidence": 1
+        }]
+        return formatted_reply

coresugg.py

@@ -0,0 +1,49 @@
+# core.py
+
+from pydantic import BaseModel
+import openai
+from environs import Env
+
+# Load environment variables
+env = Env()
+env.read_env("openai.env")  # Adjust the file name as needed
+
+# Set OpenAI API key
+openai.api_key = env.str("OPENAI_API_KEY")
+
+# Define constants from environment variables
+SYSTEM_PROMPT = env.str("SYSTEM_PROMPT", "generate 3 different friendly short conversation starter for a user to another unknown user.")
+MODEL = env.str("MODEL", "gpt-3.5-turbo")
+NUMBER_OF_MESSAGES_FOR_CONTEXT = min(env.int("NUMBER_OF_MESSAGES_FOR_CONTEXT", 4), 10)
+AI_RESPONSE_TIMEOUT = env.int("AI_RESPONSE_TIMEOUT", 20)
+
+class ConversationPayload(BaseModel):
+    fromusername: str
+    tousername: str
+    FromUserKavasQuestions: list
+    ToUserKavasQuestions: list
+    Chatmood: str
+
+def create_conversation_starter_prompt(user_questions, chatmood):
+    formatted_info = " ".join([f"{qa['Question']} - {qa['Answer']}" for qa in user_questions if qa['Answer']])
+    prompt = (f"Based on user profile info and a {chatmood} mood, "
+              f"generate 3 subtle and very short conversation starters. "
+              f"Explore various topics like travel, hobbies, movies, and not just culinary tastes. "
+              f"\nProfile Info: {formatted_info}")
+    return prompt
+
+def generate_conversation_starters(prompt):
+    try:
+        response = openai.ChatCompletion.create(
+            model=MODEL,
+            messages=[{"role": "system", "content": prompt}],
+            temperature=0.7,
+            max_tokens=100,
+            n=1,
+            request_timeout=AI_RESPONSE_TIMEOUT
+        )
+        return response.choices[0].message["content"]
+    except openai.error.OpenAIError as e:
+        raise Exception(f"OpenAI API error: {str(e)}")
+    except Exception as e:
+        raise Exception(f"Unexpected error: {str(e)}")