Update app.py

app.py

@@ -3,19 +3,27 @@ from openai import OpenAI
 from datetime import datetime
 import gradio as gr
 import time
+import openai # Already imported OpenAI above, this line is redundant
 
 # --- Constants ---
-DEFAULT_MODEL = "gpt-4.1"  # Assuming gpt-4o is a good default
-DEFAULT_TEMPERATURE = 1.0 # Match your example
-DEFAULT_TOP_P = 1.0       # Match your example
-DEFAULT_FREQ_PENALTY = 0  # Match your example
-DEFAULT_PRES_PENALTY = 0  # Match your example
-MAX_TOKENS = 2048       # Match your example
+# Use a model available in the dropdown as the default
+DEFAULT_MODEL = "gpt-4o-mini-2024-07-18"
+DEFAULT_TEMPERATURE = 1.0
+DEFAULT_TOP_P = 1.0
+DEFAULT_FREQ_PENALTY = 0
+DEFAULT_PRES_PENALTY = 0
+MAX_TOKENS = 2048 # This is often controlled by the model, but can be a limit
 MAX_HISTORY_LENGTH = 5
 
 # --- API Key and Client Initialization ---
-import openai
+# Ensure the API key is set in your Hugging Face Space secrets
 API_KEY = os.getenv("OPENAI_API_KEY")
+if not API_KEY:
+    # Provide a clear error message if the key is missing
+    # In a real HF Space, you might raise an exception or disable the UI
+    print("Error: OPENAI_API_KEY environment variable not set.")
+    # Consider adding a gr.Markdown warning in the UI as well if API_KEY is None
+    # For now, we'll let it proceed, but OpenAI() will likely raise an error later.
 client = OpenAI(api_key=API_KEY)
 
 # --- Helper Functions ---
@@ -24,137 +32,199 @@ def get_openai_response(prompt, model=DEFAULT_MODEL, temperature=DEFAULT_TEMPERA
                         max_tokens=MAX_TOKENS, system_prompt="", chat_history=None):
     """Gets a response from the OpenAI API, handling errors and streaming."""
     today_day = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    try:
-        messages = [{"role": "system", "content": f"Todays date is: {today_day} " + system_prompt}]
-        if chat_history:
-            for turn in chat_history:
-                messages.append({"role": "user", "content": turn[0]})
-                messages.append({"role": "assistant", "content": turn[1]})
-        messages.append({"role": "user", "content": prompt})
+    messages = []
+    # Add system prompt if provided
+    effective_system_prompt = f"Today's date is: {today_day}. {system_prompt}".strip()
+    if effective_system_prompt:
+         messages.append({"role": "system", "content": effective_system_prompt})
+
+    # Add chat history
+    if chat_history:
+        for turn in chat_history:
+            # Ensure turn has two elements before trying to access them
+            if len(turn) == 2 and turn[0] is not None and turn[1] is not None:
+                 messages.append({"role": "user", "content": str(turn[0])}) # Ensure content is string
+                 messages.append({"role": "assistant", "content": str(turn[1])}) # Ensure content is string
+            # else: # Optional: Handle malformed history entries
+            #     print(f"Skipping malformed history entry: {turn}")
+
+    # Add the current user prompt
+    messages.append({"role": "user", "content": prompt})
 
+    try:
+        # *** This is the correct, modern API call for chat models ***
         response = client.chat.completions.create(
             model=model,
             messages=messages,
             temperature=temperature,
-            max_tokens=max_tokens, #Use the new name
+            max_tokens=max_tokens, # Correct parameter name for this call
             top_p=top_p,
             frequency_penalty=frequency_penalty,
             presence_penalty=presence_penalty,
-            response_format={"type": "text"},  # As per your example
-            stream=True  # Enable streaming!
+            # response_format={"type": "text"}, # Usually not needed unless forcing JSON etc. Let model decide default.
+            stream=True  # Enable streaming
         )
 
         collected_messages = []
+        full_reply_content = "" # Initialize before loop
         for chunk in response:
-            chunk_message = chunk.choices[0].delta.content
-            if chunk_message is not None:
+            # Check if delta and content exist before accessing
+            if chunk.choices and chunk.choices[0].delta and chunk.choices[0].delta.content is not None:
+                chunk_message = chunk.choices[0].delta.content
                 collected_messages.append(chunk_message)
-            full_reply_content = ''.join(collected_messages)
-            yield full_reply_content
+                full_reply_content = ''.join(collected_messages)
+                yield full_reply_content # Yield the accumulated message
 
+    # Use specific exceptions from the openai library
     except openai.APIConnectionError as e:
-        return f"Error: Could not connect to OpenAI API: {e}"
+        print(f"OpenAI API request failed: {e}")
+        yield f"Error: Could not connect to OpenAI API. {e}"
     except openai.RateLimitError as e:
-        return f"Error: Rate limit exceeded: {e}"
+        print(f"OpenAI API request failed: {e}")
+        yield f"Error: Rate limit exceeded. Please try again later. {e}"
+    except openai.AuthenticationError as e:
+        print(f"OpenAI API request failed: {e}")
+        yield f"Error: Authentication failed. Check your API key. {e}"
     except openai.APIStatusError as e:
-        return f"Error: OpenAI API returned an error: {e}"
+        print(f"OpenAI API request failed: {e}")
+        yield f"Error: OpenAI API returned an error (Status: {e.status_code}). {e}"
     except Exception as e:
-        return f"An unexpected error occurred: {e}"
-
+        print(f"An unexpected error occurred: {e}")
+        yield f"An unexpected error occurred: {e}"
 
 
 def update_ui(message, chat_history, model, temperature, top_p, frequency_penalty, presence_penalty, system_prompt, history_length):
     """Updates the Gradio UI; handles streaming response."""
+    if not message: # Don't send empty messages
+        yield "", chat_history
+        return
+
+    # Trim history before sending to API if it's longer than needed for context
+    # (Optional optimization, the API call does include full history passed here)
+    # history_for_api = chat_history[-(MAX_HISTORY_LENGTH*2):] # Keep pairs
+
     bot_message_gen = get_openai_response(
         prompt=message, model=model, temperature=temperature, top_p=top_p,
         frequency_penalty=frequency_penalty, presence_penalty=presence_penalty,
-        system_prompt=system_prompt, chat_history=chat_history
+        system_prompt=system_prompt, chat_history=chat_history # Pass full history for context
     )
-    chat_history.append((message, ""))
-    for bot_message in bot_message_gen:
-        chat_history[-1] = (chat_history[-1][0], bot_message)
-        visible_history = chat_history[-history_length:]
-        time.sleep(0.025) #Rate limiter
+
+    chat_history.append((message, "")) # Add user message and placeholder for bot response
+
+    # Stream the response
+    for bot_message_chunk in bot_message_gen:
+        chat_history[-1] = (message, bot_message_chunk) # Update the last entry with the streamed chunk
+        # Control visibility based on the slider
+        visible_history = chat_history[-int(history_length):] if history_length > 0 else []
+        # time.sleep(0.02) # Slightly shorter delay might feel more responsive
         yield "", visible_history
 
 # --- Gradio Interface ---
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# Chat with GPT-4.5 -> gpt-4.5-preview-2025-02-27 model")
-    gr.Markdown("❗⚠️IMPORTANT:!!! GPT 4.5 IS NO LONGER WORKING ON THIS SPACE, IT WAS FREE FOR ~ 4 HOURS! 02/27/2025| Made by: [@diegocabezas01](https://x.com/diegocabezas01) on X")
+    # Keep your informative Markdown sections
+    gr.Markdown("# Chat with OpenAI Models") # Updated Title
+    gr.Markdown("❗ GPT-4.5 experiment details from Feb 27, 2025...") # Keep context
     gr.Markdown("☕ [Buy me a Coffee](https://buymeacoffee.com/diegocp01m)")
     gr.Markdown("---")
     gr.Markdown("""
-    🚀 **GPT-4.5 EXPERIMENT:** GPT-4.5 was released today at 3 PM ET, but it's only available to PRO users and developers. 
-    I created a Hugging Face Space using the API so everyone can chat with GPT-4.5 for FREE—until my credits run out! 😄
-    
-    **Here's how the experiment went:**
-    
+    🚀 **GPT-4.5 EXPERIMENT RECAP:** GPT-4.5 was briefly accessible via API on Feb 27, 2025.
+    This space allowed free access during that window.
+
     📊 **Chat Completions Metrics (Feb 27, 2025):**
     - 111 requests
     - 64,764 Total tokens processed
     - Total spend: $10.99
-    
+
     This space went live at 4:23 PM ET, Feb 27, 2025 until 8:53 PM ET. [Read More](https://x.com/diegocabezas01/status/1895291365376041045)
     Results from OpenAI platform: 👇
     """)
-
     gr.Image("https://pbs.twimg.com/media/Gk1tVnRXkAASa2U?format=jpg&name=4096x4096", elem_id="gpt4_5_image")
-    gr.Markdown("Chat for Free with GPT 4o mini here: 👇")
-    
+    gr.Markdown("Chat with available models like GPT-4o mini below: 👇")
+
     with gr.Row():
         with gr.Column(scale=4):
             chatbot = gr.Chatbot(
+                label="Chat Window", # Added label for clarity
                 show_label=False,
                 avatar_images=(
-                    "https://cdn-icons-png.flaticon.com/512/8428/8428718.png",  # User image URL
-                    "https://upload.wikimedia.org/wikipedia/commons/thumb/e/ef/ChatGPT-Logo.svg/640px-ChatGPT-Logo.svg.png"  # OpenAI image URL
+                    # Using generic user icon
+                    "https://cdn-icons-png.flaticon.com/512/1077/1077114.png", # User
+                    # Using generic AI icon
+                    "https://cdn-icons-png.flaticon.com/512/8649/8649540.png" # AI
                 ),
                 render_markdown=True,
-                height=500
+                height=500,
+                bubble_full_width=False # Optional: makes bubbles look nicer
+            )
+            msg = gr.Textbox(
+                label="Your Message", # Added label
+                placeholder="Type your message here and press Enter...",
+                scale=4,
+                show_label=False,
+                container=False # Makes it sit closer to the button
             )
-            msg = gr.Textbox(placeholder="Type your message here...", scale=4, show_label=False)
 
             with gr.Accordion("Advanced Options", open=False):
                 model_select = gr.Dropdown(
                     label="Model",
-                    choices=["gpt-3.5-turbo-0125", "gpt-4o-mini-2024-07-18"],  # Update with your models
-                    value=DEFAULT_MODEL,
+                    # Ensure these models are available to your API key
+                    choices=["gpt-4o-mini-2024-07-18", "gpt-3.5-turbo-0125", "gpt-4o"],
+                    value=DEFAULT_MODEL, # Use the constant defined above
                     interactive=True
                 )
-                temperature_slider = gr.Slider(label="Temperature", minimum=0.0, maximum=2.0, value=DEFAULT_TEMPERATURE, step=0.1, interactive=True)
-                top_p_slider = gr.Slider(label="Top P", minimum=0.0, maximum=1.0, value=DEFAULT_TOP_P, step=0.05, interactive=True)
-                frequency_penalty_slider = gr.Slider(label="Frequency Penalty", minimum=-2.0, maximum=2.0, value=DEFAULT_FREQ_PENALTY, step=0.1, interactive=True)
-                presence_penalty_slider = gr.Slider(label="Presence Penalty", minimum=-2.0, maximum=2.0, value=DEFAULT_PRES_PENALTY, step=0.1, interactive=True)
-                system_prompt_textbox = gr.Textbox(label="System Prompt", placeholder="Enter a custom system prompt...", lines=3, interactive=True)
-                history_length_slider = gr.Slider(label="Chat History Length", minimum=1, maximum=20, value=MAX_HISTORY_LENGTH, step=1, interactive=True)
-
+                temperature_slider = gr.Slider(label="Temperature (Randomness)", minimum=0.0, maximum=2.0, value=DEFAULT_TEMPERATURE, step=0.1, interactive=True)
+                top_p_slider = gr.Slider(label="Top P (Nucleus Sampling)", minimum=0.0, maximum=1.0, value=DEFAULT_TOP_P, step=0.05, interactive=True)
+                frequency_penalty_slider = gr.Slider(label="Frequency Penalty (Discourage repetition)", minimum=-2.0, maximum=2.0, value=DEFAULT_FREQ_PENALTY, step=0.1, interactive=True)
+                presence_penalty_slider = gr.Slider(label="Presence Penalty (Discourage repeating topics)", minimum=-2.0, maximum=2.0, value=DEFAULT_PRES_PENALTY, step=0.1, interactive=True)
+                system_prompt_textbox = gr.Textbox(label="System Prompt", placeholder="e.g., You are a helpful assistant.", lines=3, interactive=True)
+                history_length_slider = gr.Slider(label="Chat History Display Length", minimum=1, maximum=20, value=MAX_HISTORY_LENGTH, step=1, interactive=True)
 
             with gr.Row():
-                send = gr.Button("Send")
-                clear = gr.Button("Clear")
+                 # Place clear button first maybe?
+                 clear = gr.Button("Clear Chat")
+                 send = gr.Button("Send Message", variant="primary") # Make send more prominent
+
 
     # --- Event Handlers ---
-    send_event = send.click(
+    # Define reusable inputs list
+    inputs = [
+        msg, chatbot, model_select, temperature_slider, top_p_slider,
+        frequency_penalty_slider, presence_penalty_slider, system_prompt_textbox,
+        history_length_slider
+    ]
+    # Define reusable outputs list
+    outputs = [msg, chatbot]
+
+    # Connect send button click
+    send.click(
         update_ui,
-        [msg, chatbot, model_select, temperature_slider, top_p_slider, frequency_penalty_slider, presence_penalty_slider, system_prompt_textbox, history_length_slider],
-        [msg, chatbot]
+        inputs=inputs,
+        outputs=outputs,
+        queue=True # Use queue for handling multiple users potentially
     )
+
+    # Connect textbox submit (Enter key)
     msg.submit(
         update_ui,
-        [msg, chatbot, model_select, temperature_slider, top_p_slider, frequency_penalty_slider, presence_penalty_slider, system_prompt_textbox, history_length_slider],
-        [msg, chatbot]
+        inputs=inputs,
+        outputs=outputs,
+        queue=True
     )
-    clear.click(lambda: None, None, chatbot, queue=False)
+
+    # Connect clear button
+    # Clears the message box and the chatbot history
+    clear.click(lambda: (None, []), None, outputs=[msg, chatbot], queue=False)
 
     gr.Examples(
-        examples=["Tell me about quantum computing", "Write a short poem about AI", "How can I improve my Python skills?"],
-        inputs=msg
+        examples=["Tell me about the latest AI developments", "Write a short story about a friendly robot", "Explain black holes simply"],
+        inputs=msg,
+        label="Example Prompts" # Add label
     )
-    msg.focus()
+    # msg.focus() # Autoselect msg box - Sometimes causes issues, use if needed
 
 # --- Launch ---
 if __name__ == "__main__":
-    demo.launch()
-
-
-
+    # Add share=True for a public link if running locally and want to share
+    # Add debug=True for more verbose logging during development
+    demo.queue() # Enable queue for better handling of multiple requests
+    demo.launch()