Update app.py

app.py

@@ -1,10 +1,10 @@
-# streamlit_app.py
+# app.py
 """
-Single-file Streamlit app (no Dockerfile required).
-- Saves data to ./data/victims.json (auto-created)
-- Uses OPENAI_API_KEY env var or temporary UI key input
-- Checks and optionally resets /root/.streamlit/config.toml if malformed
-- Run locally with: streamlit run streamlit_app.py
+Streamlit First Aid Assistant
+- Single-file Streamlit app
+- Saves victim records to ./data/victims.json
+- Uses OPENAI_API_KEY (env var) or temporary UI key in session (not persisted)
+- Adjusted for safer defaults and improved UI/UX
 """
 
 import os
@@ -12,18 +12,17 @@ import json
 import traceback
 from datetime import datetime
 from pathlib import Path
-from fastapi import FastAPI
 import streamlit as st
 
 # -----------------------
-# Configuration / Paths
+# Paths / Configuration
 # -----------------------
 APP_DIR = Path.cwd()
 DATA_DIR = APP_DIR / "data"
 DATA_FILE = DATA_DIR / "victims.json"
-STREAMLIT_ROOT_CONFIG = Path("/root/.streamlit/config.toml")  # common in containers
+NEXT_STEP_FILE = DATA_DIR / "next_step.json"
+STREAMLIT_ROOT_CONFIG = Path("/root/.streamlit/config.toml")
 
-# Ensure data dir exists
 DATA_DIR.mkdir(parents=True, exist_ok=True)
 
 # -----------------------
@@ -47,17 +46,20 @@ NORMAL_WOUND_STEPS = [
     "If bleeding continues or wound is deep, seek medical help.",
 ]
 
+
 def get_steps(wound_type: str):
     return SNAKEBITE_STEPS if wound_type == "poisoned" else NORMAL_WOUND_STEPS
 
 # -----------------------
 # Data helpers
 # -----------------------
+
 def ensure_datafile():
     DATA_DIR.mkdir(parents=True, exist_ok=True)
     if not DATA_FILE.exists():
         DATA_FILE.write_text("[]", encoding="utf-8")
 
+
 def save_victim_info(victim: dict):
     ensure_datafile()
     try:
@@ -70,7 +72,7 @@ def save_victim_info(victim: dict):
                 data = []
             victim_record = {
                 "timestamp": datetime.utcnow().isoformat() + "Z",
-                **victim
+                **victim,
             }
             data.append(victim_record)
             f.seek(0)
@@ -78,41 +80,74 @@ def save_victim_info(victim: dict):
             f.truncate()
         return victim_record
     except Exception as e:
-        raise
+        # bubble up a friendly error
+        raise RuntimeError(f"Failed to save victim info: {e}")
+
+
+def write_next_step(wound_type: str):
+    try:
+        DATA_DIR.mkdir(parents=True, exist_ok=True)
+        NEXT_STEP_FILE.write_text(json.dumps({"wound_type": wound_type, "created_at": datetime.utcnow().isoformat() + "Z"}), encoding="utf-8")
+    except Exception:
+        pass
 
 # -----------------------
 # OpenAI integration
 # -----------------------
 DEFAULT_MODEL = os.environ.get("OPENAI_MODEL", "gpt-4o-mini")
 
-# Option 1 (recommended): set OPENAI_API_KEY environment variable.
-_env_api_key = "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"
+# Prefer secure sources for API key:
+# 1) Environment variable OPENAI_API_KEY
+# 2) Streamlit secrets (if deployed to Streamlit sharing / Hugging Face etc)
+# 3) Temporary UI key stored in session_state (not persisted to disk)
 
-# We'll allow a temporary in-UI key (not persisted) via session_state if user pastes it.
 if "ui_api_key" not in st.session_state:
     st.session_state.ui_api_key = None
 
-def get_effective_api_key():
-    """Prefer env var, fallback to temporary UI key."""
-    return _env_api_key or st.session_state.ui_api_key
 
-# Lazy import OpenAI only when needed
-def make_openai_client(api_key):
+def get_effective_api_key():
+    env_key = os.environ.get("OPENAI_API_KEY")
+    secret_key = None
     try:
-        from openai import OpenAI
+        secret_key = st.secrets.get("OPENAI_API_KEY") if hasattr(st, "secrets") else None
     except Exception:
-        return None, "openai package is not installed. Add 'openai' to requirements.txt and rebuild."
+        secret_key = None
+    return env_key or secret_key or st.session_state.ui_api_key
+
+
+def make_openai_client(api_key):
+    # attempt to import modern OpenAI client, fall back to classic openai
     if not api_key:
         return None, "OpenAI API key not set. Provide OPENAI_API_KEY env var or paste a temporary key in the UI (not recommended for production)."
     try:
+        # modern package
+        from openai import OpenAI
+
         client = OpenAI(api_key=api_key)
         return client, None
-    except Exception as e:
-        return None, f"Failed to create OpenAI client: {e}"
+    except Exception:
+        try:
+            import openai
+
+            openai.api_key = api_key
+            return openai, None
+        except Exception:
+            return None, "openai package not installed or failed to import. Add 'openai' to requirements.txt and rebuild/deploy."
+
 
 def extract_text_from_response(resp):
-    # Best-effort extraction for different SDK shapes
+    # handle multiple SDK shapes
     try:
+        # modern OpenAI SDK (client.chat.create) returns an object with .choices[0].message.content
+        if hasattr(resp, "choices") and resp.choices:
+            first = resp.choices[0]
+            # modern object
+            if hasattr(first, "message") and hasattr(first.message, "content"):
+                return first.message.content
+            # older SDK shape
+            if hasattr(first, "text"):
+                return first.text
+        # if dict-like
         if isinstance(resp, dict):
             choices = resp.get("choices")
             if choices:
@@ -122,46 +157,64 @@ def extract_text_from_response(resp):
                     if isinstance(msg, dict):
                         return msg.get("content") or msg.get("text") or str(resp)
                 return first.get("text") or str(resp)
-        # fallback to str
         return str(resp)
     except Exception:
         return str(resp)
 
+
 def query_openai(system_prompt: str, user_message: str):
     api_key = get_effective_api_key()
     client, err = make_openai_client(api_key)
     if err:
         return {"error": err}
     try:
-        response = client.chat.create(
-            model=DEFAULT_MODEL,
-            messages=[
-                {"role": "system", "content": system_prompt},
-                {"role": "user", "content": user_message},
-            ],
-            temperature=0.2,
-            max_tokens=800,
-        )
-        text = extract_text_from_response(response)
-        return {"text": text}
+        # Modern OpenAI client
+        if hasattr(client, "chat") and hasattr(client.chat, "create"):
+            response = client.chat.create(
+                model=DEFAULT_MODEL,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_message},
+                ],
+                temperature=0.2,
+                max_tokens=800,
+            )
+            text = extract_text_from_response(response)
+            return {"text": text}
+        # Classic openai package
+        if hasattr(client, "ChatCompletion"):
+            response = client.ChatCompletion.create(
+                model=DEFAULT_MODEL,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_message},
+                ],
+                temperature=0.2,
+                max_tokens=800,
+            )
+            text = extract_text_from_response(response)
+            return {"text": text}
+        # last fallback
+        return {"error": "OpenAI client present but no compatible chat method found."}
     except Exception as e:
         return {"error": f"OpenAI request failed: {e}"}
 
+
 def make_system_prompt(wound_type: str, victim_info: dict) -> str:
     return (
         f"You are an expert first aid assistant. The victim has wound_type={wound_type}.\n"
         "- Give clear, actionable, short steps that a non-professional can follow.\n"
         "- Mention when to call emergency services or go to hospital.\n"
         f"- Use the victim info below to adjust guidance:\n{json.dumps(victim_info, indent=2)}\n"
-        "Keep language concise."
+        "Keep language concise. Use numbered short steps when appropriate."
     )
 
 # -----------------------
-# Config check and repair helper
+# Config check / helper
 # -----------------------
 DEFAULT_CONFIG_TEXT = """[server]
 headless = true
-port = 7860
+port = 8501
 enableCORS = false
 address = "0.0.0.0"
 # disable XSRF to avoid the override warning
@@ -171,16 +224,14 @@ enableXsrfProtection = false
 gatherUsageStats = false
 """
 
+
 def show_and_optionally_reset_config():
-    """
-    Shows status about /root/.streamlit/config.toml and provides a safe reset button.
-    If permission prevents writing, shows the exact shell command to run as root.
-    """
     st.subheader("Streamlit config check")
     if STREAMLIT_ROOT_CONFIG.exists():
         st.info(f"Found config at `{STREAMLIT_ROOT_CONFIG}`")
         try:
             import toml
+
             raw = STREAMLIT_ROOT_CONFIG.read_text(encoding="utf-8")
             toml.loads(raw)  # validate
             st.success("Config TOML parsed successfully.")
@@ -232,11 +283,17 @@ st.markdown(
     "Start with the quick steps on the left/right, confirm completion, then proceed to the advanced assistant."
 )
 
+# Reset session controls for convenience
+if st.button("Reset session (clear) "):
+    for k in list(st.session_state.keys()):
+        del st.session_state[k]
+    st.experimental_rerun()
+
 col1, col2 = st.columns(2)
 
 with col1:
     st.subheader("Snakebite (poisoned wound)")
-    st.markdown("\n".join([f"{i+1}. {s}" for i,s in enumerate(SNAKEBITE_STEPS)]))
+    st.markdown("\n".join([f"{i+1}. {s}" for i, s in enumerate(SNAKEBITE_STEPS)]))
     snake_done = st.checkbox("I have completed these basic steps (snakebite)", key="snake_done")
     if st.button("Next → Advanced (snakebite)"):
         if not snake_done:
@@ -244,11 +301,13 @@ with col1:
         else:
             st.session_state.wound_type = "poisoned"
             st.session_state.basic_done = True
-            st.success("Proceeding to advanced assistance for snakebite. Scroll down.")
+            write_next_step("poisoned")
+            st.success("Proceeding to advanced assistance for snakebite.")
+            st.experimental_rerun()
 
 with col2:
     st.subheader("Normal wound")
-    st.markdown("\n".join([f"{i+1}. {s}" for i,s in enumerate(NORMAL_WOUND_STEPS)]))
+    st.markdown("\n".join([f"{i+1}. {s}" for i, s in enumerate(NORMAL_WOUND_STEPS)]))
     wound_done = st.checkbox("I have completed these basic steps (normal wound)", key="wound_done")
     if st.button("Next → Advanced (normal wound)"):
         if not wound_done:
@@ -256,20 +315,23 @@ with col2:
         else:
             st.session_state.wound_type = "normal"
             st.session_state.basic_done = True
-            st.success("Proceeding to advanced assistance for normal wound. Scroll down.")
+            write_next_step("normal")
+            st.success("Proceeding to advanced assistance for normal wound.")
+            st.experimental_rerun()
 
 st.markdown("---")
 
-# System status area
-with st.expander("System status & Run instructions", expanded=True):
+# System status area (useful for debugging / deployment)
+with st.expander("System status & Run instructions", expanded=False):
     st.write(f"Data file: `{DATA_FILE}`")
+    st.write(f"Next-step file: `{NEXT_STEP_FILE}`")
     st.write(f"Model (OPENAI_MODEL): `{DEFAULT_MODEL}`")
-    st.write(f"OPENAI_API_KEY env var present: `{bool(_env_api_key)}`")
-    st.write("To run locally: `streamlit run streamlit_app.py`")
-    st.write("If you removed Dockerfile, this app is ready to run directly with Streamlit or deploy to a platform.")
+    api_key_present = bool(os.environ.get("OPENAI_API_KEY") or (hasattr(st, "secrets") and st.secrets.get("OPENAI_API_KEY")))
+    st.write(f"OPENAI_API_KEY present in env/secrets: `{api_key_present}`")
+    st.write("To run locally: `streamlit run app.py`\nIf deploying to Hugging Face or another platform, add OPENAI_API_KEY to platform secrets.")
     show_and_optionally_reset_config()
 
-# Temporary UI API key input (not persisted)
+# Temporary UI API key input (not persisted to disk)
 with st.expander("(Optional) Temporary OpenAI API key (paste here for quick test)", expanded=False):
     st.warning("Do NOT paste production keys here in a public environment. This value is stored only in session memory and not saved to disk.")
     new_key = st.text_input("Temporary API key (session only)", value=st.session_state.ui_api_key or "")
@@ -293,7 +355,8 @@ if st.session_state.get("basic_done") and st.session_state.get("wound_type"):
         with col_a:
             submit = st.form_submit_button("Save info & get advanced guidance")
         with col_b:
-            st.button("Emergency — Call local services", help="Use this to indicate urgent help is needed")
+            if st.button("Emergency — Call local services"):
+                st.warning("If this is an emergency, call your local emergency number now.")
 
         if submit:
             # Validate numeric fields
@@ -328,7 +391,7 @@ if st.session_state.get("basic_done") and st.session_state.get("wound_type"):
                 st.session_state.last_saved_record = record
                 st.success("Victim info saved.")
             except Exception as e:
-                st.error(f"Failed to save victim info: {e}")
+                st.error(str(e))
                 st.write(traceback.format_exc())
                 st.stop()
 
@@ -354,7 +417,7 @@ if st.session_state.get("basic_done") and st.session_state.get("wound_type"):
     # Chat follow-ups
     st.subheader("Ask follow-up questions")
     st.markdown("Ask the assistant further questions related to the victim or care. Keep questions concise.")
-    col_in, col_btn = st.columns([4,1])
+    col_in, col_btn = st.columns([4, 1])
     with col_in:
         user_q = st.text_input("Your question", key="chat_input")
     with col_btn:
@@ -370,8 +433,10 @@ if st.session_state.get("basic_done") and st.session_state.get("wound_type"):
                     st.error(f"Assistant error: {resp['error']}")
                 else:
                     assistant_reply = resp.get("text", "").strip()
-                    st.session_state.chat_history.append({"role": "user", "text": user_q})
-                    st.session_state.chat_history.append({"role": "assistant", "text": assistant_reply})
+                    history = st.session_state.get("chat_history", [])
+                    history.append({"role": "user", "text": user_q})
+                    history.append({"role": "assistant", "text": assistant_reply})
+                    st.session_state.chat_history = history
                     st.success("Assistant responded. See conversation below.")
 
     # Conversation display
@@ -384,9 +449,14 @@ if st.session_state.get("basic_done") and st.session_state.get("wound_type"):
                 st.markdown(f"**Assistant:** {text}")
             else:
                 st.markdown(f"**User:** {text}")
+
 else:
     st.info("Start by reviewing the quick steps for Snakebite or Normal wound and confirm completion using the checkbox, then click Next → Advanced.")
 
 st.markdown("---")
-st.caption("🔒 Security: Prefer setting OPENAI_API_KEY as an environment variable (or use platform secrets). "
-           "If you paste a key into the UI it is stored only in session memory and not written to disk.")
+st.caption(
+    "🔒 Security: Prefer setting OPENAI_API_KEY as an environment variable or platform secret. "
+    "If you paste a key into the UI it is stored only in session memory and not written to disk."
+)
+
+# END