Update app.py

app.py

@@ -1,37 +1,28 @@
-#!/usr/bin/env python3
 """
-AURA Chat — Gradio Space (final working version)
-- Single-file Gradio app (UI + pipeline).
-- Locked model, tokens, and scraper delay.
-- Users input prompts, press Analyze -> app scrapes -> LLM analyzes -> seeds chat.
-- Chat UI works across Gradio versions (we render tuples for display).
-- Robust client lifecycle and shutdown cleanup.
+AURA Chat — Gradio Space
+Single-file Gradio app that:
+- Accepts newline-separated prompts (data queries) from the user.
+- On "Analyze" scrapes those queries, sends the aggregated text to a locked LLM,
+  and returns a polished analysis with a ranked list of best stocks and an
+  "Investment Duration" for each stock.
+- Seeds a chat component with the generated analysis; user can then chat about it.
+
+Notes:
+- Model, max tokens, and delay between scrapes are fixed.
+- User only inputs prompts; everything else is predefined.
 """
 
 import os
-import sys
 import time
-import asyncio
 import requests
+import asyncio
 import atexit
-import traceback
-import html
-import gc
-import socket
-from typing import List, Tuple, Dict, Any
+from typing import List
 
 import gradio as gr
 
-# Defensive event loop setup early (reduces fd shutdown noise)
-if sys.platform != "win32":
-    try:
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-    except Exception:
-        traceback.print_exc()
-
 # -----------------------
-# Config (locked)
+# Configuration (fixed)
 # -----------------------
 SCRAPER_API_URL = os.getenv("SCRAPER_API_URL", "https://deep-scraper-96.created.app/api/deep-scrape")
 SCRAPER_HEADERS = {"User-Agent": "Mozilla/5.0", "Content-Type": "application/json"}
@@ -43,14 +34,8 @@ SCRAPE_DELAY = float(os.getenv("SCRAPE_DELAY", "1.0"))
 OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
 OPENAI_BASE_URL = os.getenv("OPENAI_BASE_URL", "https://openrouter.ai/api/v1")
 
-# Try import OpenAI SDK; if missing, we'll error cleanly on use
-try:
-    from openai import OpenAI
-except Exception:
-    OpenAI = None
-
 # -----------------------
-# System prompt (locked)
+# Prompt engineering (fixed)
 # -----------------------
 PROMPT_TEMPLATE = f"""
 You are AURA, a concise, professional hedge-fund research assistant.
@@ -58,40 +43,35 @@ You are AURA, a concise, professional hedge-fund research assistant.
 Task:
 - Given scraped data below, produce a clear, readable analysis that:
   1) Lists the top 5 stock picks (or fewer if not enough data).
-  2) For each stock provide: Ticker / Company name, 2 short rationale bullets,
-     and an explicit Investment Duration: one-line "When to Invest" and one-line "When to Sell".
-  3) Provide a 2–3 sentence summary conclusion at the top.
-  4) After the list, include "Assumptions & Risks" (2–3 bullets).
-  5) Keep it scannable and human-friendly; use numbered lists and bold headers. No JSON.
-
+  2) For each stock provide: Ticker / Company name, short rationale (2-3 bullets),
+     and an explicit **Investment Duration** entry: one-line "When to Invest" and one-line "When to Sell".
+  3) Keep each stock entry short and scannable. Use a bullet list or numbered list.
+  4) At the top, provide a 2-3 sentence summary conclusion.
+  5) Output in plain text, clean formatting.
+  6) Include a concise "Assumptions & Risks" section (2-3 bullet points).
+Max tokens for the LLM response: {MAX_TOKENS}
 Model: {LLM_MODEL}
-Max tokens: {MAX_TOKENS}
 """
 
 # -----------------------
-# Helpers: scraping & LLM
+# Scraping
 # -----------------------
 def deep_scrape(query: str, retries: int = 3, timeout: int = 40) -> str:
     payload = {"query": query}
     last_err = None
-    for attempt in range(1, retries + 1):
+    for attempt in range(retries):
         try:
             resp = requests.post(SCRAPER_API_URL, headers=SCRAPER_HEADERS, json=payload, timeout=timeout)
             resp.raise_for_status()
             data = resp.json()
             if isinstance(data, dict):
-                parts = []
-                for k, v in data.items():
-                    parts.append(f"{k.upper()}:\n{v}\n")
-                return "\n".join(parts)
-            return str(data)
+                return "\n".join(f"{k.upper()}:\n{v}" for k, v in data.items())
+            else:
+                return str(data)
         except Exception as e:
             last_err = e
-            if attempt < retries:
-                time.sleep(1.0)
-            else:
-                return f"ERROR: Scraper failed: {e}"
-    return f"ERROR: {last_err}"
+            time.sleep(1.0)
+    return f"ERROR: Scraper failed: {last_err}"
 
 def multi_scrape(queries: List[str], delay: float = SCRAPE_DELAY) -> str:
     aggregated = []
@@ -100,269 +80,165 @@ def multi_scrape(queries: List[str], delay: float = SCRAPE_DELAY) -> str:
         if not q:
             continue
         aggregated.append(f"\n=== QUERY: {q} ===\n")
-        scraped = deep_scrape(q)
-        aggregated.append(scraped)
+        aggregated.append(deep_scrape(q))
         time.sleep(delay)
     return "\n".join(aggregated)
 
-def call_llm(system_prompt: str, user_text: str, model: str = LLM_MODEL, max_tokens: int = MAX_TOKENS) -> str:
-    # Validate dependencies & secrets
+# -----------------------
+# LLM call
+# -----------------------
+try:
+    from openai import OpenAI
+except ImportError:
+    OpenAI = None
+
+def run_llm_system_and_user(system_prompt: str, user_text: str) -> str:
     if OpenAI is None:
-        return "ERROR: openai package not installed. Add 'openai' to requirements."
+        return "ERROR: `openai` package not installed."
     if not OPENAI_API_KEY:
         return "ERROR: OPENAI_API_KEY not set in environment."
 
-    client = None
+    client = OpenAI(base_url=OPENAI_BASE_URL, api_key=OPENAI_API_KEY)
     try:
-        client = OpenAI(base_url=OPENAI_BASE_URL, api_key=OPENAI_API_KEY)
         completion = client.chat.completions.create(
-            model=model,
-            messages=[
-                {"role": "system", "content": system_prompt},
-                {"role": "user", "content": user_text},
-            ],
-            max_tokens=max_tokens,
+            model=LLM_MODEL,
+            messages=[{"role": "system", "content": system_prompt},
+                      {"role": "user", "content": user_text}],
+            max_tokens=MAX_TOKENS
         )
-        if hasattr(completion, "choices") and len(completion.choices) > 0:
-            try:
-                return completion.choices[0].message.content
-            except Exception:
-                return str(completion.choices[0])
-        return str(completion)
+        return completion.choices[0].message.content
     except Exception as e:
         return f"ERROR: LLM call failed: {e}"
     finally:
-        # Close client transport if possible
         try:
-            if client is not None:
-                try:
-                    client.close()
-                except Exception:
-                    try:
-                        asyncio.get_event_loop().run_until_complete(client.aclose())
-                    except Exception:
-                        pass
+            client.close()
         except Exception:
             pass
 
 # -----------------------
-# Pipeline: analyze & chat helpers
+# Analysis pipeline
 # -----------------------
-def analyze_and_seed_chat(prompts_text: str) -> Tuple[str, List[Dict[str, str]]]:
-    if not prompts_text or not prompts_text.strip():
-        return "Please enter at least one data prompt (one per line).", []
+def analyze_and_seed_chat(prompts_text: str):
+    if not prompts_text.strip():
+        return "Please enter at least one prompt.", []
 
     queries = [line.strip() for line in prompts_text.splitlines() if line.strip()]
-    scraped = multi_scrape(queries, delay=SCRAPE_DELAY)
+    scraped = multi_scrape(queries)
     if scraped.startswith("ERROR"):
         return scraped, []
 
-    user_payload = f"SCRAPED DATA:\n\n{scraped}\n\nPlease produce the analysis as instructed in the system prompt."
-    analysis = call_llm(PROMPT_TEMPLATE, user_payload)
+    user_payload = f"SCRAPED DATA:\n\n{scraped}\n\nPlease follow the system instructions."
+    analysis = run_llm_system_and_user(PROMPT_TEMPLATE, user_payload)
     if analysis.startswith("ERROR"):
         return analysis, []
 
+    # Seed chat as a list of dicts
     initial_chat = [
-        {"role": "user", "content": f"Analyze the data provided (prompts: {', '.join(queries)})"},
-        {"role": "assistant", "content": analysis},
+        {"role": "user", "content": f"Analyze the data I provided (prompts: {', '.join(queries)})"},
+        {"role": "assistant", "content": analysis}
     ]
     return analysis, initial_chat
 
-def continue_chat(messages: List[Dict[str, str]], user_msg: str, analysis_text: str) -> List[Dict[str, str]]:
-    if messages is None:
-        messages = []
-    if not user_msg or not user_msg.strip():
-        return messages
-
-    messages.append({"role": "user", "content": user_msg})
-
+def continue_chat(chat_messages, user_message, analysis_text):
+    if not user_message.strip():
+        return chat_messages
+    chat_messages.append({"role": "user", "content": user_message})
     followup_system = (
-        "You are AURA, an analyst. Use the provided analysis as authoritative context. "
-        "Answer the user's question referencing the analysis where appropriate. Be concise and actionable."
+        "You are AURA, a helpful analyst. The conversation context includes a recently generated analysis."
     )
-    user_payload = f"REFERENCE ANALYSIS:\n\n{analysis_text}\n\nUSER QUESTION: {user_msg}\n\nAnswer concisely."
-    assistant_reply = call_llm(followup_system, user_payload)
-    messages.append({"role": "assistant", "content": assistant_reply})
-    return messages
-
-# -----------------------
-# Cleanup helper (reduces fd shutdown noise)
-# -----------------------
-def aggressive_cleanup_on_exit():
-    try:
-        gc.collect()
-    except Exception:
-        pass
-    try:
-        loop = asyncio.get_event_loop()
-        if loop.is_running():
-            try:
-                loop.stop()
-            except Exception:
-                pass
-        if not loop.is_closed():
-            try:
-                loop.close()
-            except Exception:
-                pass
-    except Exception:
-        pass
-    try:
-        for obj in gc.get_objects():
-            try:
-                if isinstance(obj, socket.socket):
-                    try:
-                        obj.close()
-                    except Exception:
-                        pass
-            except Exception:
-                pass
-    except Exception:
-        pass
-
-atexit.register(aggressive_cleanup_on_exit)
+    user_payload = f"REFERENCE ANALYSIS:\n\n{analysis_text}\n\nUSER QUESTION: {user_message}\n\nRespond concisely."
+    assistant_reply = run_llm_system_and_user(followup_system, user_payload)
+    chat_messages.append({"role": "assistant", "content": assistant_reply})
+    return chat_messages
+
+# Convert dict chat to Gradio format
+def convert_to_gradio_chat_format(chat_messages):
+    formatted = []
+    i = 0
+    while i < len(chat_messages):
+        if chat_messages[i]["role"] == "user":
+            user_msg = chat_messages[i]["content"]
+            assistant_msg = ""
+            if i + 1 < len(chat_messages) and chat_messages[i + 1]["role"] == "assistant":
+                assistant_msg = chat_messages[i + 1]["content"]
+                i += 1
+            formatted.append((user_msg, assistant_msg))
+        i += 1
+    return formatted
 
 # -----------------------
-# UI: build a beautiful responsive Gradio layout
+# Gradio UI
 # -----------------------
-def messages_to_tuples(messages: List[Dict[str, str]]) -> List[Tuple[str, str]]:
-    """
-    Convert our internal list of {"role","content"} dicts into a list of (user, assistant) tuples
-    suitable for gr.Chatbot. We group sequential messages by role into paired tuples.
-    This ensures compatibility across Gradio versions.
-    """
-    if not messages:
-        return []
-    pairs: List[Tuple[str, str]] = []
-    pending_user = None
-    for m in messages:
-        role = m.get("role")
-        content = m.get("content", "")
-        if role == "user":
-            pending_user = content
-        elif role == "assistant":
-            # pair with last user if available, else pair with empty user
-            user_text = pending_user or ""
-            pairs.append((user_text, content))
-            pending_user = None
-    # If there is an unmatched user at the end, append it with empty assistant
-    if pending_user:
-        pairs.append((pending_user, ""))
-    return pairs
-
 def build_ui():
     with gr.Blocks(title="AURA Chat — Hedge Fund Picks") as demo:
-        # Inject fonts & CSS
+        # Custom CSS
         gr.HTML("""
-        <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;600;700;800&display=swap" rel="stylesheet">
         <style>
-            body, .gradio-container { font-family: Inter, system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial; background: linear-gradient(180deg,#051226 0%, #07102a 100%); color: #e6eef6; }
-            .wrap { max-width:1100px; margin:18px auto; padding:12px; }
-            .top { display:flex; justify-content:space-between; align-items:center; gap:12px; margin-bottom:12px; }
-            .brand { display:flex; gap:12px; align-items:center; }
-            .logo { width:52px; height:52px; border-radius:12px; display:flex; align-items:center; justify-content:center; font-weight:800; color:#021028; background:linear-gradient(135deg,#06b6d4,#10b981); box-shadow:0 10px 30px rgba(2,6,23,0.6); font-size:20px; }
-            .title { font-size:20px; font-weight:700; margin:0; }
-            .desc { color:#9fb0c8; font-size:13px; }
-            .layout { display:flex; gap:16px; align-items:flex-start; }
-            .left { width:360px; min-width:260px; }
-            .panel { background: linear-gradient(180deg, rgba(255,255,255,0.02), rgba(255,255,255,0.01)); border-radius:12px; padding:14px; box-shadow:0 8px 40px rgba(2,6,23,0.6); border:1px solid rgba(255,255,255,0.03); }
-            .muted { color:#9fb0c8; font-size:13px; }
-            .pill { display:inline-block; padding:6px 10px; border-radius:999px; background:rgba(255,255,255,0.02); color:#bcd6e6; font-size:13px; margin-right:8px; }
-            .analysis { min-height:220px; max-height:420px; overflow:auto; white-space:pre-wrap; font-family:Inter, monospace; font-size:14px; color:#dfeefc; }
-            .chatbox { height:420px; overflow:auto; border-radius:10px; padding:8px; background: linear-gradient(180deg, rgba(255,255,255,0.01), rgba(255,255,255,0.005)); border:1px solid rgba(255,255,255,0.03); }
-            @media (max-width:900px){ .layout { flex-direction:column; } .left { width:100%; } }
+        .gradio-container { max-width: 1200px; margin: 20px auto; font-family: 'Arial', sans-serif; }
+        .analysis-box { background: #f9f9f9; border-radius: 10px; padding: 12px; box-shadow: 0 4px 12px rgba(0,0,0,0.08); }
+        .chat-box { background: #ffffff; border-radius: 10px; padding: 8px; box-shadow: 0 2px 10px rgba(0,0,0,0.05); }
         </style>
         """)
 
-        with gr.Row(elem_id="header"):
-            with gr.Column():
-                gr.HTML("<div class='wrap'><div class='top'><div class='brand'><div class='logo'>A</div><div><div class='title'>AURA — Hedge Fund Picks</div><div class='desc'>Scrape • Synthesize • Short actionable Investment Duration</div></div></div><div class='muted'>Model locked • Tokens locked</div></div></div>")
-
-        with gr.Row(elem_classes="layout"):
-            # Left column (inputs)
-            with gr.Column(elem_classes="left"):
-                with gr.Column(elem_classes="panel"):
-                    gr.Markdown("**Data Prompts**")
-                    prompts = gr.Textbox(lines=6, placeholder="SEC insider transactions october 2025\n13F filings Q3 2025\ncompany: ACME corp insider buys", label=None)
-                    with gr.Row():
-                        analyze_btn = gr.Button("Analyze", variant="primary")
-                        clear_btn = gr.Button("Clear", variant="secondary")
-                    status = gr.Markdown("Status: Idle", elem_id="status")
-                    gr.HTML(f"<div style='margin-top:8px'><span class='pill'>Model: {LLM_MODEL}</span><span class='pill'>Tokens: {MAX_TOKENS}</span><span class='pill'>Delay: {SCRAPE_DELAY}s</span></div>")
-
-            # Right column (analysis + chat)
-            with gr.Column():
-                with gr.Column(elem_classes="panel"):
-                    gr.Markdown("### Generated Analysis")
-                    analysis_html = gr.HTML("<div class='analysis muted'>No analysis yet. Enter prompts and click Analyze.</div>")
-                    gr.Markdown("### Chat (ask follow-ups)")
-                    chatbot = gr.Chatbot(label=None, elem_classes="chatbox")
-                    with gr.Row():
-                        user_input = gr.Textbox(placeholder="Ask a follow-up about the analysis...", label=None)
-                        send_btn = gr.Button("Send", variant="primary")
-
-        # Hidden states
-        analysis_state = gr.State("")      # raw analysis text
-        chat_state = gr.State([])          # list of {"role","content"} dicts
+        gr.Markdown("# AURA Chat — Hedge Fund Picks")
+        gr.Markdown("Enter data prompts (one per line). Click **Analyze**. Then chat about the generated analysis.")
+
+        with gr.Row():
+            # Left container: input
+            with gr.Column(scale=1):
+                prompts = gr.Textbox(
+                    lines=6,
+                    label="Data Prompts (one per line)",
+                    placeholder="SEC insider transactions october 2025\n13F filings Q3 2025\ncompany: ACME corp insider buys"
+                )
+                analyze_btn = gr.Button("Analyze", variant="primary")
+                error_box = gr.Markdown("", visible=False)
+                gr.Markdown(f"**Fixed settings:** Model = `{LLM_MODEL}`, Max tokens = `{MAX_TOKENS}`, Scrape delay = `{SCRAPE_DELAY}s`")
+                gr.Markdown("Add your `OPENAI_API_KEY` to Space Secrets.")
+
+            # Right container: analysis + chat
+            with gr.Column(scale=2):
+                analysis_out = gr.Textbox(label="Generated Analysis", lines=18, interactive=False, elem_classes="analysis-box")
+                gr.Markdown("**Chat with AURA about this analysis**")
+                chatbot = gr.Chatbot(label="AURA Chat", height=420, elem_classes="chat-box")
+                user_input = gr.Textbox(placeholder="Ask follow-up questions...", label="Your question")
+                send_btn = gr.Button("Send")
+
+        # States
+        analysis_state = gr.State("")
+        chat_state = gr.State([])
 
         # Handlers
-        def set_status(text: str):
-            return gr.update(value=f"Status: {text}")
-
-        def on_clear():
-            return "", gr.update(value="<div class='analysis muted'>No analysis yet. Enter prompts and click Analyze.</div>"), [], [], set_status("Cleared")
-
-        def on_analyze(prompts_text: str):
-            try:
-                if not prompts_text or not prompts_text.strip():
-                    return "", gr.update(value="<div class='analysis muted'>Please enter at least one prompt.</div>"), [], [], set_status("Idle")
-                status_update = set_status("Scraping...")
-                # immediate UI update if front-end supports streaming (not guaranteed), then do work
-                queries = [line.strip() for line in prompts_text.splitlines() if line.strip()]
-                scraped = multi_scrape(queries, delay=SCRAPE_DELAY)
-                if scraped.startswith("ERROR"):
-                    return "", gr.update(value=f"<div class='analysis muted'><strong>Error:</strong> {html.escape(scraped)}</div>"), [], [], set_status("Scrape error")
-
-                status_update = set_status("Generating analysis...")
-                user_payload = f"SCRAPED DATA:\n\n{scraped}\n\nPlease produce the analysis as instructed in the system prompt."
-                analysis_text = call_llm(PROMPT_TEMPLATE, user_payload)
-                if analysis_text.startswith("ERROR"):
-                    return "", gr.update(value=f"<div class='analysis muted'><strong>Error:</strong> {html.escape(analysis_text)}</div>"), [], [], set_status("LLM error")
-
-                safe_html = "<div class='analysis'>" + html.escape(analysis_text) + "</div>"
-                initial_chat = [
-                    {"role": "user", "content": f"Analyze the data provided (prompts: {', '.join(queries)})"},
-                    {"role": "assistant", "content": analysis_text},
-                ]
-                return analysis_text, gr.update(value=safe_html), initial_chat, initial_chat, set_status("Done")
-            except Exception as e:
-                tb = traceback.format_exc()
-                return "", gr.update(value=f"<div class='analysis muted'><strong>Unexpected error:</strong> {html.escape(str(e))}</div>"), [], [], set_status("Error")
-
-        def on_send(messages, user_msg, analysis_text):
-            if not user_msg or not user_msg.strip():
-                return messages or [], ""
-            updated = continue_chat(messages or [], user_msg, analysis_text or "")
-            return updated, ""
-
-        def render_chat(messages):
-            # Convert to tuple list for gr.Chatbot which expects [(user, assistant), ...]
-            try:
-                tuples = messages_to_tuples(messages or [])
-                return tuples
-            except Exception:
-                # fallback: show empty
-                return []
-
-        # Wire UI
-        analyze_btn.click(fn=on_analyze, inputs=[prompts], outputs=[analysis_state, analysis_html, chat_state, chatbot, status])
-        clear_btn.click(fn=on_clear, inputs=[], outputs=[prompts, analysis_html, chat_state, chatbot, status])
-
-        send_btn.click(fn=on_send, inputs=[chat_state, user_input, analysis_state], outputs=[chat_state, user_input])
-        user_input.submit(fn=on_send, inputs=[chat_state, user_input, analysis_state], outputs=[chat_state, user_input])
-
-        chat_state.change(fn=render_chat, inputs=[chat_state], outputs=[chatbot])
-
+        def on_analyze(prompts_text):
+            analysis_text, initial_chat = analyze_and_seed_chat(prompts_text)
+            if analysis_text.startswith("ERROR"):
+                return "", f"**Error:** {analysis_text}", "", []
+            return analysis_text, "", analysis_text, initial_chat
+
+        def on_send(chat_state_list, user_msg, analysis_text):
+            updated_history = continue_chat(chat_state_list or [], user_msg, analysis_text)
+            return updated_history, ""
+
+        analyze_btn.click(
+            fn=on_analyze,
+            inputs=[prompts],
+            outputs=[analysis_out, error_box, analysis_state, chat_state]
+        )
+        send_btn.click(
+            fn=on_send,
+            inputs=[chat_state, user_input, analysis_state],
+            outputs=[chat_state, user_input]
+        )
+        user_input.submit(
+            fn=on_send,
+            inputs=[chat_state, user_input, analysis_state],
+            outputs=[chat_state, user_input]
+        )
+        chat_state.change(
+            fn=convert_to_gradio_chat_format,
+            inputs=[chat_state],
+            outputs=[chatbot]
+        )
     return demo
 
 # -----------------------