commit

app.py

@@ -0,0 +1,330 @@
+import ee
+import os
+import json
+from google.oauth2 import service_account
+
+from typing import Dict
+from datetime import datetime, timedelta
+from geopy.distance import geodesic
+import requests
+import pandas as pd
+import folium
+
+import requests
+from langchain_core.tools import tool
+from langgraph.prebuilt import create_react_agent
+from typing_extensions import TypedDict, Literal, Annotated
+
+from typing import Optional
+
+from collections import Counter
+from langgraph.graph import StateGraph, END
+from typing import TypedDict, Annotated
+import operator
+from langchain_core.messages import AnyMessage, SystemMessage, HumanMessage, ToolMessage, AIMessage
+from langchain_community.tools.tavily_search import TavilySearchResults
+from langchain.chat_models import init_chat_model
+from langchain.schema import HumanMessage
+from langchain.tools import tool
+import gradio as gr
+
+
+# Load JSON string from Hugging Face secret (as env variable)
+SERVICE_KEY_JSON = os.environ.get("GEE_SERVICE_KEY")
+MISTRAL_API_KEY = os.getenv("MISTRAL_API_KEY")
+FIRMS_API_KEY = os.getenv("FIRMS_API_KEY")
+OPENCAGE_API_KEY = os.getenv("OPENCAGE_API_KEY")
+
+
+if SERVICE_KEY_JSON is None:
+    raise RuntimeError("Missing Earth Engine service account key in environment.")
+
+# Parse the JSON and create credentials
+SERVICE_KEY_DICT = json.loads(SERVICE_KEY_JSON)
+credentials = service_account.Credentials.from_service_account_info(
+    SERVICE_KEY_DICT,
+    scopes=['https://www.googleapis.com/auth/cloud-platform']
+)
+
+# Initialize EE
+ee.Initialize(credentials=credentials)
+
+
+@tool
+def get_fire_risk_map(place: str, opencage_key: str, firms_key: str, min_brightness: int = 300, min_confidence: int = 60) -> Optional[str]:
+    """
+    Returns an HTML string of a folium map showing fire locations, nearest water bodies, and fire stations.
+    Args:
+        place: Name of the place to fetch the bounding box for.
+        opencage_key: opencage API key.
+        firms_key: FIRMS API key.
+        min_brightness (int, optional): Minimum fire brightness to filter on (e.g., 300). Defaults to 300.
+        min_confidence (int, optional): Minimum confidence level (0-100) to filter fire data. Defaults to 60.
+    Returns:
+          Returns an HTML string of a folium map showing fire locations, nearest water bodies, and fire stations.
+    """
+    try:
+        opencage_key = os.environ["OPENCAGE_API_KEY"]
+        firms_key = os.environ["FIRMS_API_KEY"]
+
+        # Step 1: Get bounding box from OpenCage
+        url = f"https://api.opencagedata.com/geocode/v1/json?q={place}&key={opencage_key}"
+        resp = requests.get(url)
+        resp.raise_for_status()
+        data = resp.json()
+        bounds = data['results'][0]['bounds']
+        bbox = {
+            'north': bounds['northeast']['lat'],
+            'south': bounds['southwest']['lat'],
+            'east': bounds['northeast']['lng'],
+            'west': bounds['southwest']['lng']
+        }
+        bbox_str = f"{bbox['west']},{bbox['south']},{bbox['east']},{bbox['north']}"
+
+        # Step 2: Get FIRMS fire data
+        source = 'MODIS_NRT'
+        url = f'https://firms.modaps.eosdis.nasa.gov/api/area/csv/{firms_key}/{source}/{bbox_str}/3'
+        df = pd.read_csv(url)
+        now = datetime.utcnow()
+        df['acq_datetime'] = pd.to_datetime(
+            df['acq_date'] + ' ' + df['acq_time'].astype(str).str.zfill(4),
+            format="%Y-%m-%d %H%M"
+        )
+        df_fires_filtered = df[
+            (df['brightness'] >= min_brightness) &
+            (df['confidence'] > min_confidence) &
+            (df['acq_datetime'] > (now - timedelta(hours=24)))
+        ].dropna(subset=['latitude', 'longitude']).reset_index(drop=True)
+
+        if df_fires_filtered.empty:
+          return "<b>No significant fire activity detected in the past 24 hours for the specified location.</b>"
+
+
+        # Step 3: Water bodies (Earth Engine)
+        west, south, east, north = map(float, bbox_str.split(','))
+        geom = ee.Geometry.BBox(west, south, east, north)
+        water = ee.Image('JRC/GSW1_4/GlobalSurfaceWater').select('occurrence')
+        water_mask = water.gt(50).selfMask()
+        water_clipped = water_mask.clip(geom)
+        sampled_points = water_clipped.stratifiedSample(
+            numPoints=500,
+            classBand='occurrence',
+            region=geom,
+            scale=500,
+            geometries=True,
+            seed=42
+        ).getInfo()
+        water_points = [
+            {
+                'latitude': f['geometry']['coordinates'][1],
+                'longitude': f['geometry']['coordinates'][0]
+            }
+            for f in sampled_points['features']
+        ]
+        df_water = pd.DataFrame(water_points).dropna().reset_index(drop=True)
+
+        # Step 4: Compute nearest water body
+        def get_nearest_water(fire_lat, fire_lon):
+            fire_point = (fire_lat, fire_lon)
+            min_dist = float('inf')
+            nearest = None
+            for _, row in df_water.iterrows():
+                dist = geodesic(fire_point, (row['latitude'], row['longitude'])).km
+                if dist < min_dist:
+                    min_dist = dist
+                    nearest = row
+            return pd.Series({
+                'nearest_water_lat': nearest['latitude'],
+                'nearest_water_lon': nearest['longitude'],
+                'distance_km': min_dist
+            })
+        nearest_water = df_fires_filtered.apply(
+            lambda r: get_nearest_water(r['latitude'], r['longitude']), axis=1)
+
+        # Step 5: Fire stations using Overpass API
+        overpass_query = f"""
+        [out:json][timeout:25];
+        (
+            node["amenity"="fire_station"]({south},{west},{north},{east});
+        );
+        out body;
+        """
+        res = requests.get("http://overpass-api.de/api/interpreter", params={"data": overpass_query})
+        data = res.json()
+        stations = [
+            {
+                'name': e.get('tags', {}).get('name', 'Unnamed Station'),
+                'lat': e['lat'],
+                'lon': e['lon']
+            }
+            for e in data.get('elements', []) if 'lat' in e and 'lon' in e
+        ]
+        df_stations = pd.DataFrame(stations).dropna()
+
+        def get_nearest_station(fire_lat, fire_lon):
+            fire_point = (fire_lat, fire_lon)
+            min_dist = float('inf')
+            nearest = None
+            for _, row in df_stations.iterrows():
+                dist = geodesic(fire_point, (row['lat'], row['lon'])).km
+                if dist < min_dist:
+                    min_dist = dist
+                    nearest = row
+            return pd.Series({
+                'nearest_station_name': nearest['name'],
+                'nearest_station_lat': nearest['lat'],
+                'nearest_station_lon': nearest['lon'],
+                'station_distance_km': min_dist
+            })
+        nearest_station = df_fires_filtered.apply(
+            lambda r: get_nearest_station(r['latitude'], r['longitude']), axis=1)
+
+        # Final dataframe
+        df_final = pd.concat([df_fires_filtered, nearest_water, nearest_station], axis=1)
+
+        # Step 6: Create a folium map
+        center_lat = (bbox["north"] + bbox["south"]) / 2
+        center_lon = (bbox["east"] + bbox["west"]) / 2
+        m = folium.Map(location=[center_lat, center_lon], zoom_start=6)
+
+        for _, row in df_final.iterrows():
+            fire_loc = [row['latitude'], row['longitude']]
+            water_loc = [row['nearest_water_lat'], row['nearest_water_lon']]
+            station_loc = [row['nearest_station_lat'], row['nearest_station_lon']]
+
+            # 🔥 1. Uncertainty Zone (large faint circle) FIRST
+            folium.Circle(
+                    location=fire_loc,
+                    radius=500,  # 3 km
+                    color='orange',
+                    fill=True,
+                    fill_opacity=0.2,
+                    popup="⚠️ Possible spread zone (~3 km radius)",
+            ).add_to(m)
+
+    # 🔴 2. Fire point (small red circle) SECOND
+            folium.CircleMarker(
+                location=fire_loc,
+                radius=6,
+                color='red',
+                fill=True,
+                fill_color='red',
+                popup=f"🔥 Brightness: {row['brightness']}, Confidence: {row['confidence']}, DateTime: {row['acq_datetime']} Latitude: {row['latitude']:.3f}, Longitude: {row['longitude']:.3f}",
+            ).add_to(m)
+
+    # 💧 3. Nearest water point
+            folium.Marker(
+                  location=water_loc,
+                  icon=folium.Icon(color='blue', icon='tint', prefix='fa'),
+                  popup=f"💧 Nearest Water\nDistance: {row['distance_km']:.2f} km\nLat: {row['nearest_water_lat']:.3f}\nLon: {row['nearest_water_lon']:.3f}",
+            ).add_to(m)
+
+    # 🟢 4. Line between fire and water
+            folium.PolyLine(
+                    locations=[fire_loc, water_loc],
+                    color='green',
+                    weight=2,
+            ).add_to(m)
+
+    # 🚒 5. Nearest fire station (NEW)
+            folium.Marker(
+                  location=station_loc,
+                  icon=folium.Icon(color='darkred', icon='fire-extinguisher', prefix='fa'),
+                  popup=f"🚒 Nearest Fire Station\nDistance: {row['station_distance_km']:.2f} km\nLat: {row['nearest_station_lat']:.3f}\nLon: {row['nearest_station_lon']:.3f}",
+            ).add_to(m)
+
+    # 🧯 6. Line between fire and station (NEW)
+            folium.PolyLine(
+                  locations=[fire_loc, station_loc],
+                  color='purple',
+                  weight=2,
+                dash_array='5,10'  # dashed line
+            ).add_to(m)
+
+        return m._repr_html_()
+
+
+
+    except Exception as e:
+        return f"<b>Error generating fire risk map:</b> {str(e)}"
+    
+
+
+class AgentState(TypedDict):
+    messages: Annotated[list[AnyMessage], operator.add]
+
+class Agent:
+
+    def __init__(self, model, tools, system=""):
+        self.system = system
+        graph = StateGraph(AgentState)
+        graph.add_node("llm", self.call_mistral_ai)
+        graph.add_node("action", self.take_action)
+        graph.add_node("final", self.final_answer)
+        graph.add_conditional_edges(
+            "llm",
+            self.exists_action,
+            {True: "action", False: END}
+        )
+        graph.add_edge("action", "final")  # 🆕
+        graph.add_edge("final", END)        # 🆕
+        graph.set_entry_point("llm")
+        self.graph = graph.compile()
+        self.tools = {t.name: t for t in tools}
+        self.model = model.bind_tools(tools)
+
+    def exists_action(self, state: AgentState):
+        result = state['messages'][-1]
+        return len(result.tool_calls) > 0
+
+    def call_mistral_ai(self, state: AgentState):
+        messages = state['messages']
+        if self.system:
+            messages = [SystemMessage(content=self.system)] + messages
+        message = self.model.invoke(messages)
+        return {'messages': [message]}
+
+    def take_action(self, state: AgentState):
+        tool_calls = state['messages'][-1].tool_calls
+        results = []
+        for t in tool_calls:
+            print(f"Calling: {t}")
+            if not t['name'] in self.tools:      # check for bad tool name from LLM
+                print("\n ....bad tool name....")
+                result = "bad tool name, retry"  # instruct LLM to retry if bad
+            else:
+                result = self.tools[t['name']].invoke(t['args'])
+            results.append(ToolMessage(tool_call_id=t['id'], name=t['name'], content=str(result)))
+        return {'messages': results}
+
+    def final_answer(self, state: AgentState):
+        """Return the final tool output cleanly."""
+        return {"messages": [AIMessage(content=state['messages'][-1].content.strip())]}
+    
+
+prompt = """ You are a Wildfire Detection Assistant.
+When users ask about fire spots, wildfires, or fire mapping in any region,
+use the firespot_summary function to analyze the area and generate a fire map or status update.
+"""
+
+model = init_chat_model("mistral-large-latest", model_provider="mistralai")
+abot = Agent(model, [get_fire_risk_map], system=prompt)
+
+
+
+
+def process_prompt(prompt):
+    messages = [HumanMessage(content=prompt)]
+    result = abot.graph.invoke({"messages": messages})
+    html_map = result['messages'][-1].content  # assuming tool returns HTML string
+    return html_map
+
+iface = gr.Interface(
+    fn=process_prompt,
+    inputs=gr.Textbox(lines=2, placeholder="e.g., Check for fires in California..."),
+    outputs=gr.HTML(label="Fire Risk Map"),
+    title="Fire Risk Mapper",
+    description="Ask about fire risks in a region and view results as an interactive map."
+)
+
+iface.launch(share = True)

requirements.txt

@@ -0,0 +1,23 @@
+# Core Python libraries
+pandas
+requests
+folium
+geopy
+google-auth
+google-auth-oauthlib
+google-auth-httplib2
+
+# Earth Engine (GEE)
+earthengine-api
+
+# LangChain ecosystem
+langchain
+langgraph
+langchain-community
+langchain-core
+
+# For Gradio UI
+gradio
+
+# Typing / Compatibility
+typing-extensions