Update app.py

app.py

@@ -1,196 +1,175 @@
-import os
-import json
-import requests
-import boto3
-import streamlit as st
+###############################################################################
+# app.py – Weather Umbrella Advisor (Streamlit + OpenWeatherMap + Claude 3)  #
+###############################################################################
+import os, json, requests, boto3, streamlit as st
 from dotenv import load_dotenv
 
-# Load env (for local dev / Hugging Face secrets)
+# --------------------------------------------------------------------------- #
+# 1) Load env vars (local .env or HF Space “Secrets”)                         #
+# --------------------------------------------------------------------------- #
 load_dotenv()
-
-# Configs
 OPENWEATHERMAP_API_KEY = os.getenv("OPENWEATHERMAP_API_KEY")
-AWS_REGION = os.getenv("AWS_REGION", "us-east-1")
-
-# AWS Bedrock Runtime
-session = boto3.Session(
-    aws_access_key_id=os.getenv("AWS_ACCESS_KEY_ID"),
-    aws_secret_access_key=os.getenv("AWS_SECRET_ACCESS_KEY"),
-    region_name=AWS_REGION
-)
-bedrock_runtime = session.client("bedrock-runtime")
-
-# Streamlit Page Config
-st.set_page_config(page_title="🌤️ Weather Umbrella Advisor", page_icon="☔", layout="centered")
-
-# --- Title Section ---
+AWS_REGION            = os.getenv("AWS_REGION", "us-east-1")
+AWS_ACCESS_KEY_ID     = os.getenv("AWS_ACCESS_KEY_ID")    # may be None
+AWS_SECRET_ACCESS_KEY = os.getenv("AWS_SECRET_ACCESS_KEY")  # may be None
+
+# --- Heuristic: auto-swap if ID looks like a secret (contains “/”) ----------
+if AWS_ACCESS_KEY_ID and "/" in AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY and "/" not in AWS_SECRET_ACCESS_KEY:
+    AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY = AWS_SECRET_ACCESS_KEY, AWS_ACCESS_KEY_ID
+
+# --------------------------------------------------------------------------- #
+# 2) Create Bedrock client, preferring explicit keys if they’re present        #
+# --------------------------------------------------------------------------- #
+if AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY:
+    session = boto3.Session(
+        aws_access_key_id     = AWS_ACCESS_KEY_ID,
+        aws_secret_access_key = AWS_SECRET_ACCESS_KEY,
+        region_name           = AWS_REGION,
+    )
+else:
+    # Falls back to IAM role or default credentials chain
+    session = boto3.Session(region_name=AWS_REGION)
+
+bedrock = session.client("bedrock-runtime")
+
+# Quick sanity-check – will raise if creds are still wrong
+try:
+    _ = bedrock.meta.region_name  # simple attribute access forces no call
+except Exception as e:
+    st.error(f"Credential problem: {e}")
+    st.stop()
+
+# --------------------------------------------------------------------------- #
+# 3) Streamlit page style                                                     #
+# --------------------------------------------------------------------------- #
+st.set_page_config(page_title="🌤️ Umbrella Advisor", page_icon="☔", layout="centered")
 st.markdown("""
-<div style="text-align: center;">
-    <h1 style="color: #3c79f5;">☔ Weather Umbrella Advisor</h1>
-    <p style="font-size: 18px;">Ask me if you need to carry an umbrella tomorrow, powered by <b>Claude + OpenWeatherMap</b>.</p>
+<div style="text-align:center">
+  <h1 style="color:#3c79f5;">☔ Weather Umbrella Advisor</h1>
+  <p style="font-size:18px">Ask if you need an umbrella tomorrow – powered by <b>Claude 3</b> &amp; <b>OpenWeatherMap</b>.</p>
 </div>
 """, unsafe_allow_html=True)
 
-# Chat history state
+# --------------------------------------------------------------------------- #
+# 4) Conversation state                                                       #
+# --------------------------------------------------------------------------- #
 if "messages" not in st.session_state:
     st.session_state.messages = []
 
-# --- Display Past Messages ---
-for msg in st.session_state.messages:
-    with st.chat_message(msg["role"]):
-        st.markdown(msg["content"])
-
-# --- Weather API Call ---
-def get_weather(location):
-    """Fetches weather data for next 24 hours for given city."""
-    if not location.strip():
-        return {"error": "Please specify a valid location."}
-    
+for m in st.session_state.messages:
+    with st.chat_message(m["role"]):
+        st.markdown(m["content"])
+
+# --------------------------------------------------------------------------- #
+# 5) Helper – get weather                                                     #
+# --------------------------------------------------------------------------- #
+def get_weather(city: str):
+    if not city.strip():
+        return {"error": "Please give me a city name."}
+
+    geo = f"http://api.openweathermap.org/geo/1.0/direct?q={city}&limit=1&appid={OPENWEATHERMAP_API_KEY}"
     try:
-        geo_url = f"http://api.openweathermap.org/geo/1.0/direct?q={location}&limit=1&appid={OPENWEATHERMAP_API_KEY}"
-        geo_resp = requests.get(geo_url).json()
-        if not geo_resp:
-            return {"error": f"Location '{location}' not found."}
-        
-        lat, lon = geo_resp[0]['lat'], geo_resp[0]['lon']
-        weather_url = f"http://api.openweathermap.org/data/2.5/forecast?lat={lat}&lon={lon}&appid={OPENWEATHERMAP_API_KEY}&units=metric"
-        weather_data = requests.get(weather_url).json()
-        if 'list' not in weather_data:
-            return {"error": f"Unable to fetch weather forecast for '{location}'."}
-
-        forecast = [{
+        loc = requests.get(geo, timeout=10).json()
+        if not loc:
+            return {"error": f"City “{city}” not found."}
+        lat, lon = loc[0]["lat"], loc[0]["lon"]
+        wurl = f"http://api.openweathermap.org/data/2.5/forecast?lat={lat}&lon={lon}&appid={OPENWEATHERMAP_API_KEY}&units=metric"
+        data = requests.get(wurl, timeout=10).json()
+        if "list" not in data:
+            return {"error": f"No forecast for “{city}”."}
+        fc = [{
             "time": f["dt_txt"],
             "description": f["weather"][0]["description"].capitalize(),
-            "rain_probability": round(f.get("pop", 0) * 100, 1),
-            "temp": f["main"]["temp"],
-            "humidity": f["main"]["humidity"]
-        } for f in weather_data['list'][:8]]  # 24 hrs = 8 x 3hr blocks
-
-        return {"location": location.title(), "forecast": forecast}
-    
+            "rain_probability": round(f.get("pop", 0)*100, 1),
+            "temp": f["main"]["temp"]
+        } for f in data["list"][:8]]
+        return {"location": city.title(), "forecast": fc}
     except Exception as e:
         return {"error": str(e)}
 
-# --- ReAct-Powered Response Generator ---
-def generate_react_response(user_input, conversation_history=""):
-    """Uses Claude with ReAct to give umbrella recommendation."""
-    system_prompt = """You are a helpful assistant using the ReAct (Reasoning + Acting) method to answer whether the user should carry an umbrella tomorrow.
+# --------------------------------------------------------------------------- #
+# 6) Helper – talk to Claude (ReAct)                                          #
+# --------------------------------------------------------------------------- #
+SYSTEM_PROMPT = """You are a helpful umbrella advisor using ReAct:
 
-Steps:
 1. Think about the question.
-2. Act using get_weather(location).
-3. Observe the weather data.
-4. Reason and give a clear answer.
+2. If needed, act with get_weather(location).
+3. Observe results.
+4. Reason and answer.
 
-When you need weather data, reply in this format:
-{
-  "thought": "Need weather info for [location]",
-  "action": "get_weather",
-  "action_input": {"location": "city_name"}
-}
+When you need weather data, respond EXACTLY:
+{"thought":"…","action":"get_weather","action_input":{"location":"City"}}"""
 
-If no location is mentioned, ask the user to specify one.
-
-If you have the weather data, give a natural reply like:
-"You do not need an umbrella tomorrow in London, as it's expected to be sunny and dry."
-"""
-
-    messages = [{"role": "user", "content": f"{system_prompt}\n\nChat history:\n{conversation_history}\n\nUser: {user_input}"}]
-
-    claude_body = {
+def ask_claude(user, history=""):
+    # First call
+    body = {
         "anthropic_version": "bedrock-2023-05-31",
         "max_tokens": 1000,
         "temperature": 0.7,
         "top_p": 0.9,
-        "messages": messages
+        "messages": [{
+            "role": "user",
+            "content": f"{SYSTEM_PROMPT}\n\nHistory:\n{history}\n\nUser: {user}"
+        }]
     }
-
-    response = bedrock_runtime.invoke_model(
+    raw = bedrock.invoke_model(
         modelId="anthropic.claude-3-sonnet-20240229-v1:0",
         contentType="application/json",
         accept="application/json",
-        body=json.dumps(claude_body),
+        body=json.dumps(body)
     )
-    content = json.loads(response["body"].read())["content"][0]["text"].strip()
+    txt = json.loads(raw["body"].read())["content"][0]["text"].strip()
 
-    # Try parsing ReAct JSON
+    # Try to parse ReAct JSON
     try:
-        parsed = json.loads(content)
-        if parsed.get("action") == "get_weather":
-            location = parsed["action_input"]["location"]
-            if not location:
-                return "Please tell me which city you're asking about 🌍."
-
-            weather_data = get_weather(location)
-            if "error" in weather_data:
-                return weather_data["error"]
-
-            forecast_str = json.dumps(weather_data, indent=2)
-            reasoning_prompt = f"""Based on this weather forecast for {location}, give an umbrella recommendation:
-
-{forecast_str}
-
-Return a natural response that includes:
-- Location
-- Conditions (rain %, sky, etc.)
-- Clear YES/NO umbrella advice
-"""
-            final_response = bedrock_runtime.invoke_model(
+        j = json.loads(txt)
+        if j.get("action") == "get_weather":
+            city = j["action_input"]["location"]
+            wx = get_weather(city)
+            if "error" in wx: return wx["error"]
+
+            # Second call – reasoning
+            reason_prompt = f"""Here is the forecast for {city}:
+
+{json.dumps(wx, indent=2)}
+
+Give a friendly answer: YES/NO umbrella, with reasoning."""
+            body2 = {
+                "anthropic_version": "bedrock-2023-05-31",
+                "max_tokens": 500,
+                "temperature": 0.7,
+                "messages":[{"role":"user","content":reason_prompt}]
+            }
+            raw2 = bedrock.invoke_model(
                 modelId="anthropic.claude-3-sonnet-20240229-v1:0",
                 contentType="application/json",
                 accept="application/json",
-                body=json.dumps({
-                    "anthropic_version": "bedrock-2023-05-31",
-                    "max_tokens": 500,
-                    "temperature": 0.7,
-                    "messages": [{"role": "user", "content": reasoning_prompt}]
-                })
+                body=json.dumps(body2)
             )
-            return json.loads(final_response["body"].read())["content"][0]["text"].strip()
-
+            return json.loads(raw2["body"].read())["content"][0]["text"].strip()
     except json.JSONDecodeError:
-        pass  # Possibly just a reply from Claude
-
-    return content
+        pass
+    return txt
 
-# --- Chat Input Handling ---
-def build_convo_history():
-    return "\n".join([f"{m['role'].capitalize()}: {m['content']}" for m in st.session_state.messages[-4:]])
+# --------------------------------------------------------------------------- #
+# 7) Chat input                                                               #
+# --------------------------------------------------------------------------- #
+def last_history(n=4):
+    return "\n".join(f"{m['role'].capitalize()}: {m['content']}" for m in st.session_state.messages[-n:])
 
-if user_prompt := st.chat_input("Ask: Do I need an umbrella tomorrow?"):
-    st.session_state.messages.append({"role": "user", "content": user_prompt})
-    with st.chat_message("user"):
-        st.markdown(user_prompt)
+if prompt := st.chat_input("Ask: Do I need an umbrella tomorrow?"):
+    st.session_state.messages.append({"role":"user","content":prompt})
+    with st.chat_message("user"): st.markdown(prompt)
 
     with st.chat_message("assistant"):
-        with st.spinner("Thinking... 🤔"):
-            history = build_convo_history()
-            response = generate_react_response(user_prompt, history)
-            st.markdown(response)
-
-    st.session_state.messages.append({"role": "assistant", "content": response})
-
-# --- Sidebar ---
+        with st.spinner("Thinking…"):
+            reply = ask_claude(prompt, last_history())
+            st.markdown(reply)
+    st.session_state.messages.append({"role":"assistant","content":reply})
+
+# --------------------------------------------------------------------------- #
+# 8) Sidebar                                                                  #
+# --------------------------------------------------------------------------- #
 with st.sidebar:
     st.image("https://img.icons8.com/clouds/100/umbrella.png", width=100)
-    st.markdown("## ☀️ About")
-    st.markdown("""
-**Weather Assistant** gives you umbrella advice using:
-- 🌦️ Real-time weather via **OpenWeatherMap**
-- 🧠 Smart reasoning via **Claude (Bedrock)**
-- 🤖 ReAct method: Think • Act • Observe • Reason
-
----
-
-### 💬 Try Saying
-- "Should I bring an umbrella tomorrow?"
-- "Will it rain in Delhi tomorrow?"
-- "Do I need an umbrella in Tokyo?"
-
----
-
-### 🔧 Tools Used
-- Claude 3 Sonnet (Bedrock)
-- OpenWeatherMap API
-- Streamlit (frontend)
-""")
+    st.markdown("### About\nUses **Claude 3 Sonnet (Bedrock)** + **OpenWeatherMap**")