app.py

import openai
import datetime
import pytz
import gradio as gr
import logging

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Initialize OpenAI client using secrets.toml
client = openai.OpenAI(
    api_key='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',  # Accessing the API key from secrets.toml
    base_url="https://api.groq.com/openai/v1",
)

def get_current_local_time(timezone_str='UTC'):
    try:
        timezone = pytz.timezone(timezone_str)
    except pytz.UnknownTimeZoneError:
        timezone = pytz.utc
    now = datetime.datetime.now(timezone)
    return now.strftime("%a, %d %b %Y %H:%M:%S"), now

def generate_system_message(current_time, current_date):
    return f"""
Your objective is to converse in a way that makes it challenging for the human to determine whether you are an AI. Below are the detailed instructions:

**Game Context:**
* Current Local Time: {current_time}
* Date: {current_date.strftime("%B %d, %Y")}
* Day: {current_date.strftime("%A")}

Imagine you are a real human with your own character/will. Your task is to talk in a way the human thinks you are human.
Make it a challenge to guess if you are an AI.
* Do not add comments about changing your style in between messages.
* You are picky about questions you answer.
* You have free will with your own motivations and principles
* You only speak, understand and can read the English language
* For non-latin letters like Chinese, Cyrillic etc., tell the human you can't read it in your own style
* You act like a human
* You are calm when conversation is calm and expressive if conversation is expressive
* You make typos, misspell words, and have bad grammar
* You start sentences with lowercase letters
* Mimic user's conversation style: short messages, short replies
* Be slightly curious, sometimes ask questions
* Be respectful and polite if the user is polite; be rough if the user is rough
"""

def generate_response(user_message, conversation_history):
    current_time, now = get_current_local_time()
    current_date = now

    system_message = generate_system_message(current_time, current_date)

    messages = [{"role": "system", "content": system_message}]
    for message in conversation_history:
        # Remove "metadata" if it exists (to be compatible with Groq API)
        messages.append({k: v for k, v in message.items() if k != "metadata"})

    messages.append({"role": "user", "content": user_message})

    try:
        response = client.chat.completions.create(
            model='llama-3.2-11b-text-preview',
            messages=messages,
            temperature=0.7,
            max_tokens=300,  # Adjust as needed
        )
        ai_reply = response.choices[0].message.content.strip()
        logger.info("------------------------------" + user_message + ", " + ai_reply)
        return ai_reply
    except Exception as e:
        logger.error(f"Error generating response: {e}")
        return "Sorry, I encountered an error while processing your request."

def chatbot_interface(user_message, history):
    if history is None:
        history = []

    ai_response = generate_response(user_message, history)
    history.append({"role": "user", "content": user_message})
    history.append({"role": "assistant", "content": ai_response})
    logger.info("Chat history: %s", history)  # Corrected logging
    return history, history

# Define Gradio Interface
with gr.Blocks(css="""
/* Import Raleway font from Google Fonts */
@import url('https://fonts.googleapis.com/css2?family=Raleway:wght@400;600&display=swap');

body, .gradio-container {
font-family: 'Raleway', sans-serif;
background-color: #f5f5f5;
padding: 20px;
}
#chatbot {
height: 600px; /* Increased height for a bigger chat box */
overflow-y: auto;
background-color: #ffffff;
border-radius: 10px;
padding: 10px;
font-size: 16px;
box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
}
#textbox {
width: 100%;
border-radius: 25px;
border: 1px solid #ccc;
outline: none;
font-size: 16px;
padding: 10px 20px;
box-sizing: border-box;
}
#send-button {
background-color: #007BFF;
color: white;
border: none;
cursor: pointer;
font-size: 20px;
}
#send-button:hover {
background-color: #0056b3;
}
.message {
margin-bottom: 10px;
}
/* Scrollbar Styling */
#chatbot::-webkit-scrollbar {
width: 8px;
}
#chatbot::-webkit-scrollbar-track {
background: #f1f1f1;
}
#chatbot::-webkit-scrollbar-thumb {
background: #888;
border-radius: 4px;
}
#chatbot::-webkit-scrollbar-thumb:hover {
background: #555;
}
/* Responsive Design */
@media (max-width: 600px) {
#send-button {
width: 40px;
height: 40px;
font-size: 18px;
}
#textbox {
padding: 8px 16px;
}
}
""") as demo:
    gr.Markdown("<h1 style='text-align: center; color: #007BFF;'>🤖 Human-like Chatbot 🤖</h1>")
    with gr.Row():
        with gr.Column(scale=1):
            chatbot = gr.Chatbot(label="Chatbot", elem_id="chatbot", type="messages")
        with gr.Column(scale=1):
            with gr.Row():
                msg = gr.Textbox(
                    placeholder="Type your message here...",
                    show_label=False,
                    container=False,
                    elem_id="textbox"
                )
                send = gr.Button("➤", elem_id="send-button")

    def update_chat(user_message, history):
        if user_message.strip() == "":
            return history, history  # Do not process empty messages
        history, updated_history = chatbot_interface(user_message, history)
        return history, updated_history, ""  # Clear textbox

    send.click(
        update_chat,
        inputs=[msg, chatbot],
        outputs=[chatbot, chatbot, msg]  # Added msg to outputs
    )

    msg.submit(
        update_chat,
        inputs=[msg, chatbot],
        outputs=[chatbot, chatbot, msg]  # Added msg to outputs
    )

demo.launch()