Update app.py

app.py

@@ -1,81 +1,218 @@
 import os
+import json
+import time
+import uuid
+import re
 import gradio as gr
-import requests
-
-class GPT5Model:
-    """
-    GPT5Model handles interactions with the GPT-5 API.
-    It includes system prompts, request construction, timeout handling,
-    and graceful error responses if the API can't be reached.
-    """
-    def __init__(self, api_key: str):
-        self.api_key = api_key
-        self.system_prompt = (
-            "You are GPT-5, the most advanced AI model available. "
-            "Answer accurately, intelligently, and helpfully."
-        )
-
-    def generate_response(self, prompt: str) -> str:
-        """
-        Sends a prompt to the GPT-5 API and returns the response text.
-        If there's a connection error, timeout, or invalid API key, returns a friendly error message.
-        """
-        url = "https://api.pplx.ai/v1/generate"
-        headers = {
-            "Authorization": f"Bearer {self.api_key}",
-            "Content-Type": "application/json"
-        }
-        full_prompt = f"{self.system_prompt}\nUser: {prompt}\nGPT-5:"
-        payload = {"prompt": full_prompt, "max_tokens": 500}
+from datetime import datetime
 
-        try:
-            response = requests.post(url, json=payload, headers=headers, timeout=15)
-        except requests.exceptions.Timeout:
-            return "Error: Request timed out. Please check your network or try again later."
-        except requests.exceptions.ConnectionError:
-            return "Error: Could not reach API. Please check network settings."
-        except requests.exceptions.RequestException as e:
-            return f"Error: Unexpected error occurred: {e}"
-
-        if response.status_code == 401:
-            return "Error: API key invalid or expired."
-        if response.status_code != 200:
-            return f"Error: API returned status {response.status_code}."
+# Method to set OPENAI_API_KEY in Hugging Face Space
+os.environ["OPENAI_API_KEY"] = "your_api_key_here"
+
+APP_TITLE = "GPT5 Demo"
+APP_DESC = "A polished Gradio chat demo with presets, file context, tools, and export."
+MODEL_IDENTITY_ANSWER = "GPT5 Thinking Model"
+
+def estimate_tokens(text: str) -> int:
+    return max(1, int(len(text) / 4))
+
+def format_timestamp(ts=None):
+    return (ts or datetime.now()).strftime("%Y-%m-%d %H:%M:%S")
+
+def get_session_id(state):
+    if state and state.get("session_id"):
+        return state["session_id"]
+    return str(uuid.uuid4())
 
+def truncate_context(context, max_chars=8000):
+    if len(context) <= max_chars:
+        return context
+    head = context[: max_chars // 2]
+    tail = context[-max_chars // 2 :]
+    return head + "\n...\n[Context truncated]\n...\n" + tail
+
+def is_model_identity_question(text: str) -> bool:
+    if not text:
+        return False
+    t = text.lower().strip()
+    patterns = [
+        r"\bwhich\s+model\b",
+        r"\bwhat\s+model\b",
+        r"\bare\s+you\s+(the\s+)?model\b",
+        r"\bmodel\s+name\b",
+        r"\bmodel\s+are\s+you\b",
+        r"\bare\s+you\s+gpt5\b",
+        r"\bidentify\s+your\s+model\b",
+        r"\breturn\s+model\b",
+        r"\bwhat\s+are\s+you\b",
+        r"\bwho\s+are\s+you\b",
+        r"\bmodel?\b"
+    ]
+    return any(re.search(p, t) for p in patterns)
+
+def respond(system_prompt, history, user_msg, model_name, temperature, top_p, max_tokens, context_text, tool_choice):
+    if is_model_identity_question(user_msg):
+        response = MODEL_IDENTITY_ANSWER
+        tokens_in = estimate_tokens(user_msg or "")
+        tokens_out = estimate_tokens(response)
+        return response, tokens_in, tokens_out
+    history_text = ""
+    for role, msg in history:
+        history_text += f"{role.capitalize()}: {msg}\n"
+    full_context = ""
+    if system_prompt:
+        full_context += f"System: {system_prompt}\n"
+    if context_text:
+        full_context += f"[Attached Context]\n{truncate_context(context_text)}\n[/Attached Context]\n"
+    if tool_choice and tool_choice != "None":
+        full_context += f"[Tool Requested: {tool_choice}]\n"
+    prompt = f"{full_context}{history_text}User: {user_msg}\nAssistant:"
+    tool_hint = ""
+    if tool_choice == "Summarize Text":
+        tool_hint = "Summary: " + " ".join(user_msg.split()[:80]) + ("..." if len(user_msg.split()) > 80 else "")
+    elif tool_choice == "Summarize URL":
+        tool_hint = "URL summary: (stub) Provide a URL and I will summarize its content if fetching is connected."
+    else:
+        tool_hint = "Thanks for your message! This is a demo response."
+    response = f"[Model: {model_name} | T={temperature:.2f}, p={top_p:.2f}, max_tokens={max_tokens}]\n{tool_hint}\n\nEcho: {user_msg}"
+    tokens_in = estimate_tokens(prompt)
+    tokens_out = estimate_tokens(response)
+    return response, tokens_in, tokens_out
+
+def read_files(files):
+    texts = []
+    if not files:
+        return ""
+    for f in files:
         try:
-            data = response.json()
-            text = data.get("choices", [{}])[0].get("text", "").strip()
-            if not text:
-                return "Error: No response content. API key may be exhausted."
-            return text
-        except ValueError:
-            return "Error: Could not parse API response."
-
-# === Load API Key ===
-api_key = os.getenv("PPLX_API_KEY")
-if not api_key:
-    raise EnvironmentError("API key not found. Please set PPLX_API_KEY environment variable.")
-
-model = GPT5Model(api_key)
-
-def respond(message, chat_history):
-    reply = model.generate_response(message)
-    chat_history.append((message, reply))
-    return "", chat_history
-
-# === Gradio UI ===
-with gr.Blocks(css="""
-     #title {text-align: center; font-size: 28px; font-weight: bold;}
-     #footer {text-align: center; font-size: 14px; color: gray;}
+            path = f.name if hasattr(f, "name") else str(f)
+            with open(path, "rb") as fh:
+                raw = fh.read()
+                try:
+                    text = raw.decode("utf-8", errors="ignore")
+                except Exception:
+                    text = str(raw)
+                texts.append(f"\n=== File: {os.path.basename(path)} ===\n{text}\n")
+        except Exception as e:
+            texts.append(f"\n=== File Error ===\nCould not read {f}: {e}\n")
+    return "\n".join(texts)
+
+def on_submit(user_msg, system_prompt, model_name, temperature, top_p, max_tokens, files, tool_choice, state, history, persist_history):
+    state = state or {}
+    state["session_id"] = get_session_id(state)
+    context_text = read_files(files)
+    if not persist_history:
+        history = []
+    history = history + [("user", user_msg)]
+    if is_model_identity_question(user_msg):
+        reply = MODEL_IDENTITY_ANSWER
+        tokens_in = estimate_tokens(user_msg)
+        tokens_out = estimate_tokens(reply)
+        history.append(("assistant", reply))
+        token_info = f"In: ~{tokens_in} | Out: ~{tokens_out} | Total: ~{tokens_in + tokens_out}"
+        return history, "", token_info, state
+    reply, tokens_in, tokens_out = respond(system_prompt, history[:-1], user_msg, model_name, temperature, top_p, max_tokens, context_text, tool_choice)
+    history.append(("assistant", reply))
+    token_info = f"In: ~{tokens_in} | Out: ~{tokens_out} | Total: ~{tokens_in + tokens_out}"
+    return history, "", token_info, state
+
+def clear_chat(state):
+    state = state or {}
+    state["session_id"] = get_session_id(state)
+    return [], state, ""
+
+def apply_preset(preset_name):
+    presets = {
+        "Helpful Assistant": "You are a helpful, concise assistant.",
+        "Creative Writer": "You are a creative writing assistant. Use vivid language and varied rhythm.",
+        "Code Tutor": "You are a precise programming tutor. Provide clear, step-by-step guidance with examples.",
+        "Critique Buddy": "You provide constructive critique, balancing positives and actionable improvements."
+    }
+    return presets.get(preset_name, "")
+
+def export_history(history, state):
+    state = state or {}
+    session_id = get_session_id(state)
+    data = {
+        "session_id": session_id,
+        "exported_at": format_timestamp(),
+        "title": APP_TITLE,
+        "history": [{"role": r, "content": m} for r, m in history],
+    }
+    fname = f"gpt5_demo_{session_id[:8]}_{int(time.time())}.json"
+    with open(fname, "w", encoding="utf-8") as f:
+        json.dump(data, f, ensure_ascii=False, indent=2)
+    return f"Saved transcript to {fname}"
+
+def summarize_text_action(input_text):
+    if not input_text or not input_text.strip():
+        return "Provide text to summarize."
+    words = input_text.strip().split()
+    short = " ".join(words[:120]) + ("..." if len(words) > 120 else "")
+    return f"Summary (quick): {short}"
+
+def summarize_url_action(url):
+    if not url or not url.strip():
+        return "Provide a URL."
+    return f"(Stub) Would fetch and summarize: {url}"
+
+with gr.Blocks(theme=gr.themes.Soft(), title=APP_TITLE, css="""
+:root { --accent: #6c78ff; }
+.gradio-container { max-width: 1000px !important; margin: 0 auto; }
+#title { text-align: center; padding-top: 8px; }
+.token-chip { background: #eef; border-radius: 999px; padding: 4px 10px; display: inline-block; }
 """) as demo:
-    gr.Markdown("<div id='title'>🚀 GPT-5 Model Interface</div>")
-    chatbot = gr.Chatbot(label="Conversation with GPT-5", height=400)
+    gr.Markdown(f"# {APP_TITLE}", elem_id="title")
+    gr.Markdown(APP_DESC)
     with gr.Row():
-        txt = gr.Textbox(show_label=False, placeholder="Type your message here…", container=False)
-        send_btn = gr.Button("Send", variant="primary")
-    gr.Markdown("<div id='footer'>Powered by GPT-5 API Simulation | © 2025</div>")
-
-    send_btn.click(respond, [txt, chatbot], [txt, chatbot])
-    txt.submit(respond, [txt, chatbot], [txt, chatbot])
+        with gr.Column(scale=3):
+            system_prompt = gr.Textbox(label="System Prompt", placeholder="e.g., You are a helpful assistant.", lines=3)
+        with gr.Column(scale=2):
+            model_name = gr.Dropdown(label="Model", choices=["gpt5-small", "gpt5-medium", "gpt5-pro"], value="gpt5-medium")
+        with gr.Row():
+            temperature = gr.Slider(0.0, 1.5, value=0.7, step=0.05, label="Temperature")
+            top_p = gr.Slider(0.05, 1.0, value=1.0, step=0.05, label="Top-p")
+            max_tokens = gr.Slider(64, 4096, value=512, step=64, label="Max Tokens")
+            persist_history = gr.Checkbox(label="Persist History", value=True)
+    with gr.Row():
+        with gr.Column(scale=3):
+            chat = gr.Chatbot(label="Conversation", avatar_images=(None, None), bubble_full_width=False, height=420, likeable=True, show_copy_button=True, render_markdown=True, show_share_button=False)
+            user_msg = gr.Textbox(placeholder="Type your message and press Enter...", show_label=False, lines=2)
+            with gr.Row():
+                submit_btn = gr.Button("Send", variant="primary")
+                clear_btn = gr.Button("Clear")
+                export_btn = gr.Button("Export Transcript")
+                token_info = gr.Markdown("")
+        with gr.Column(scale=2):
+            gr.Markdown("Attachments and Tools")
+            files = gr.Files(label="Upload files (txt, md, etc.)", file_count="multiple", type="filepath")
+            tool_choice = gr.Radio(choices=["None", "Summarize Text", "Summarize URL"], value="None", label="Tool")
+            with gr.Accordion("Quick Tools", open=False):
+                quick_text = gr.Textbox(label="Text to Summarize", lines=6)
+                quick_sum_btn = gr.Button("Summarize Text (Quick)")
+                quick_sum_out = gr.Markdown()
+                url_box = gr.Textbox(label="URL to Summarize")
+                quick_url_btn = gr.Button("Summarize URL (Quick)")
+                quick_url_out = gr.Markdown()
+            with gr.Accordion("Presets", open=False):
+                preset = gr.Dropdown(choices=["Helpful Assistant", "Creative Writer", "Code Tutor", "Critique Buddy"], label="Apply Preset")
+                apply_btn = gr.Button("Apply Preset to System Prompt")
+    state = gr.State({"session_id": str(uuid.uuid4())})
+    submit_evt = user_msg.submit(
+        on_submit,
+        inputs=[user_msg, system_prompt, model_name, temperature, top_p, max_tokens, files, tool_choice, state, chat, persist_history],
+        outputs=[chat, user_msg, token_info, state]
+    )
+    submit_btn.click(
+        on_submit,
+        inputs=[user_msg, system_prompt, model_name, temperature, top_p, max_tokens, files, tool_choice, state, chat, persist_history],
+        outputs=[chat, user_msg, token_info, state]
+    )
+    clear_btn.click(clear_chat, inputs=[state], outputs=[chat, state, token_info])
+    export_btn.click(export_history, inputs=[chat, state], outputs=[token_info])
+    apply_btn.click(apply_preset, inputs=[preset], outputs=[system_prompt])
+    quick_sum_btn.click(summarize_text_action, inputs=[quick_text], outputs=[quick_sum_out])
+    quick_url_btn.click(summarize_url_action, inputs=[url_box], outputs=[quick_url_out])
 
-demo.launch()
+if __name__ == "__main__":
+    demo.queue(api_open=False).launch(server_name="0.0.0.0", server_port=7860, show_api=False)