Spaces:
Sleeping
Sleeping
| import streamlit as st | |
| import requests | |
| from datetime import datetime, timedelta | |
| import pandas as pd | |
| import plotly.express as px | |
| import plotly.graph_objects as go | |
| from plotly.subplots import make_subplots | |
| import numpy as np | |
| import os | |
| import folium | |
| from streamlit_folium import st_folium | |
| import json | |
| import time | |
| from geopy.geocoders import Nominatim | |
| from geopy.distance import geodesic | |
| import warnings | |
| warnings.filterwarnings('ignore') | |
| # Secure API key handling | |
| def get_groq_api_key(): | |
| """Securely get GROQ API key from environment variables or Streamlit secrets""" | |
| # Try to get from Streamlit secrets first | |
| try: | |
| return st.secrets["GROQ_API_KEY"] | |
| except: | |
| # Fallback to environment variable | |
| api_key = os.getenv("GROQ_API_KEY") | |
| if not api_key: | |
| st.error("🔐 GROQ API key not found. Please configure it in Streamlit secrets or environment variables.") | |
| st.info(""" | |
| **To configure the API key:** | |
| 1. **For Hugging Face Spaces**: Add `GROQ_API_KEY` in your Space settings under 'Repository secrets' | |
| 2. **For local development**: Set environment variable `GROQ_API_KEY=your_key_here` | |
| 3. **For Streamlit Cloud**: Add to secrets.toml file | |
| """) | |
| return None | |
| return api_key | |
| # Color schemes for different magnitude levels | |
| MAGNITUDE_COLORS = { | |
| 'Low': '#00ff00', # Green | |
| 'Moderate': '#ffff00', # Yellow | |
| 'High': '#ff8000', # Orange | |
| 'Severe': '#ff0000', # Red | |
| 'Extreme': '#800000' # Dark Red | |
| } | |
| # Risk assessment thresholds | |
| RISK_THRESHOLDS = { | |
| 'low': {'count': 5, 'max_magnitude': 3.0}, | |
| 'moderate': {'count': 10, 'max_magnitude': 4.5}, | |
| 'high': {'count': 20, 'max_magnitude': 5.5}, | |
| 'severe': {'count': 30, 'max_magnitude': 6.5}, | |
| 'extreme': {'count': 50, 'max_magnitude': 7.0} | |
| } | |
| # Emergency protocols | |
| EMERGENCY_PROTOCOLS = { | |
| 'low': "Monitor situation. No immediate action required.", | |
| 'moderate': "Stay alert. Review emergency plans.", | |
| 'high': "Prepare emergency kit. Stay informed.", | |
| 'severe': "Follow evacuation orders if issued. Seek shelter.", | |
| 'extreme': "IMMEDIATE EVACUATION. Follow emergency services." | |
| } | |
| def get_groq_summary(prompt, context=""): | |
| """Enhanced Groq LLM function with secure API key handling""" | |
| api_key = get_groq_api_key() | |
| if not api_key: | |
| return "AI Analysis unavailable - API key not configured" | |
| try: | |
| # Import Groq only when needed to avoid errors if not installed | |
| from groq import Groq | |
| client = Groq(api_key=api_key) | |
| full_prompt = f"{context}\n\n{prompt}" if context else prompt | |
| response = client.chat.completions.create( | |
| model="llama-3.3-70b-versatile", | |
| messages=[ | |
| {"role": "system", "content": "You are an expert seismologist, emergency response specialist, and public safety advisor. Provide detailed, accurate, and actionable information."}, | |
| {"role": "user", "content": full_prompt} | |
| ], | |
| max_tokens=2048, | |
| temperature=0.7, | |
| top_p=0.9, | |
| presence_penalty=0.1, | |
| frequency_penalty=0.1 | |
| ) | |
| return response.choices[0].message.content | |
| except ImportError: | |
| return "AI Analysis unavailable - Groq library not installed" | |
| except Exception as e: | |
| return f"AI Analysis Error: {str(e)}" | |
| def fetch_earthquakes(min_magnitude=2.5, hours=24, region_bbox=None, detailed=True): | |
| """Fetch earthquake data with enhanced error handling and data processing""" | |
| try: | |
| endtime = datetime.utcnow() | |
| starttime = endtime - timedelta(hours=hours) | |
| url = "https://earthquake.usgs.gov/fdsnws/event/1/query" | |
| params = { | |
| "format": "geojson", | |
| "starttime": starttime.strftime('%Y-%m-%dT%H:%M:%S'), | |
| "endtime": endtime.strftime('%Y-%m-%dT%H:%M:%S'), | |
| "minmagnitude": min_magnitude, | |
| "orderby": "time", | |
| "limit": 500 if detailed else 200 | |
| } | |
| if region_bbox: | |
| params.update({ | |
| "minlatitude": region_bbox[1], | |
| "maxlatitude": region_bbox[3], | |
| "minlongitude": region_bbox[0], | |
| "maxlongitude": region_bbox[2], | |
| }) | |
| response = requests.get(url, params=params, timeout=30) | |
| response.raise_for_status() | |
| data = response.json() | |
| features = data.get('features', []) | |
| earthquakes = [] | |
| for f in features: | |
| prop = f['properties'] | |
| geom = f['geometry'] | |
| earthquake = { | |
| 'time': datetime.utcfromtimestamp(prop['time']/1000), | |
| 'place': prop['place'], | |
| 'magnitude': prop['mag'], | |
| 'longitude': geom['coordinates'][0], | |
| 'latitude': geom['coordinates'][1], | |
| 'depth': geom['coordinates'][2], | |
| 'url': prop['url'], | |
| 'type': prop.get('type', 'earthquake'), | |
| 'status': prop.get('status', 'automatic'), | |
| 'tsunami': prop.get('tsunami', 0), | |
| 'felt': prop.get('felt', 0), | |
| 'cdi': prop.get('cdi', 0), | |
| 'mmi': prop.get('mmi', 0), | |
| 'alert': prop.get('alert', ''), | |
| 'sig': prop.get('sig', 0) | |
| } | |
| earthquake['risk_level'] = calculate_risk_level(earthquake['magnitude']) | |
| earthquake['time_ago'] = calculate_time_ago(earthquake['time']) | |
| earthquakes.append(earthquake) | |
| df = pd.DataFrame(earthquakes) | |
| if not df.empty: | |
| df['magnitude_category'] = df['magnitude'].apply(categorize_magnitude) | |
| df['depth_category'] = df['depth'].apply(categorize_depth) | |
| df['hour_of_day'] = df['time'].dt.hour | |
| df['day_of_week'] = df['time'].dt.day_name() | |
| return df | |
| except requests.exceptions.RequestException as e: | |
| st.error(f"Network error: {e}") | |
| return pd.DataFrame() | |
| except Exception as e: | |
| st.error(f"Data processing error: {e}") | |
| return pd.DataFrame() | |
| def calculate_risk_level(magnitude): | |
| """Calculate risk level based on magnitude""" | |
| if magnitude >= 7.0: | |
| return 'Extreme' | |
| elif magnitude >= 6.0: | |
| return 'Severe' | |
| elif magnitude >= 5.0: | |
| return 'High' | |
| elif magnitude >= 4.0: | |
| return 'Moderate' | |
| else: | |
| return 'Low' | |
| def categorize_magnitude(magnitude): | |
| """Categorize magnitude for analysis""" | |
| if magnitude >= 7.0: | |
| return 'Major (≥7.0)' | |
| elif magnitude >= 6.0: | |
| return 'Strong (6.0-6.9)' | |
| elif magnitude >= 5.0: | |
| return 'Moderate (5.0-5.9)' | |
| elif magnitude >= 4.0: | |
| return 'Light (4.0-4.9)' | |
| else: | |
| return 'Minor (<4.0)' | |
| def categorize_depth(depth): | |
| """Categorize depth for analysis""" | |
| if depth < 70: | |
| return 'Shallow (<70km)' | |
| elif depth < 300: | |
| return 'Intermediate (70-300km)' | |
| else: | |
| return 'Deep (>300km)' | |
| def calculate_time_ago(time): | |
| """Calculate time ago in human readable format""" | |
| now = datetime.utcnow() | |
| diff = now - time | |
| if diff.days > 0: | |
| return f"{diff.days} day(s) ago" | |
| elif diff.seconds >= 3600: | |
| hours = diff.seconds // 3600 | |
| return f"{hours} hour(s) ago" | |
| elif diff.seconds >= 60: | |
| minutes = diff.seconds // 60 | |
| return f"{minutes} minute(s) ago" | |
| else: | |
| return "Just now" | |
| def analyze_seismic_patterns(df): | |
| """Analyze seismic patterns and trends""" | |
| if df.empty: | |
| return {} | |
| analysis = {} | |
| try: | |
| # Only calculate distributions if we have data | |
| if len(df) > 0: | |
| analysis['hourly_distribution'] = df['hour_of_day'].value_counts().sort_index() | |
| analysis['daily_distribution'] = df['day_of_week'].value_counts() | |
| # Magnitude statistics - only if we have magnitude data | |
| if 'magnitude' in df.columns and len(df) > 0: | |
| analysis['magnitude_stats'] = { | |
| 'mean': df['magnitude'].mean(), | |
| 'median': df['magnitude'].median(), | |
| 'std': df['magnitude'].std(), | |
| 'max': df['magnitude'].max(), | |
| 'min': df['magnitude'].min() | |
| } | |
| # Depth statistics - only if we have depth data | |
| if 'depth' in df.columns and len(df) > 0: | |
| analysis['depth_stats'] = { | |
| 'mean': df['depth'].mean(), | |
| 'median': df['depth'].median(), | |
| 'std': df['depth'].std() | |
| } | |
| # Risk distribution - only if we have risk level data | |
| if 'risk_level' in df.columns and len(df) > 0: | |
| analysis['risk_distribution'] = df['risk_level'].value_counts() | |
| # Geographic center - only if we have multiple data points | |
| if len(df) > 1 and 'latitude' in df.columns and 'longitude' in df.columns: | |
| analysis['geographic_center'] = { | |
| 'lat': df['latitude'].mean(), | |
| 'lon': df['longitude'].mean() | |
| } | |
| except Exception as e: | |
| st.warning(f"Error in pattern analysis: {str(e)}") | |
| return {} | |
| return analysis | |
| def calculate_overall_risk(df): | |
| """Calculate overall risk assessment""" | |
| if df.empty: | |
| return 'low', "No recent seismic activity" | |
| count = len(df) | |
| max_magnitude = df['magnitude'].max() | |
| risk_score = 0 | |
| if count >= RISK_THRESHOLDS['extreme']['count']: | |
| risk_score += 40 | |
| elif count >= RISK_THRESHOLDS['severe']['count']: | |
| risk_score += 30 | |
| elif count >= RISK_THRESHOLDS['high']['count']: | |
| risk_score += 20 | |
| elif count >= RISK_THRESHOLDS['moderate']['count']: | |
| risk_score += 10 | |
| if max_magnitude >= RISK_THRESHOLDS['extreme']['max_magnitude']: | |
| risk_score += 40 | |
| elif max_magnitude >= RISK_THRESHOLDS['severe']['max_magnitude']: | |
| risk_score += 30 | |
| elif max_magnitude >= RISK_THRESHOLDS['high']['max_magnitude']: | |
| risk_score += 20 | |
| elif max_magnitude >= RISK_THRESHOLDS['moderate']['max_magnitude']: | |
| risk_score += 10 | |
| if risk_score >= 60: | |
| risk_level = 'extreme' | |
| elif risk_score >= 40: | |
| risk_level = 'severe' | |
| elif risk_score >= 25: | |
| risk_level = 'high' | |
| elif risk_score >= 10: | |
| risk_level = 'moderate' | |
| else: | |
| risk_level = 'low' | |
| return risk_level, f"Risk Score: {risk_score}/80" | |
| def create_advanced_map(df, region_bbox=None): | |
| """Create an advanced interactive map""" | |
| if df.empty: | |
| return None | |
| center_lat = df['latitude'].mean() | |
| center_lon = df['longitude'].mean() | |
| m = folium.Map( | |
| location=[center_lat, center_lon], | |
| zoom_start=6, | |
| tiles='OpenStreetMap' | |
| ) | |
| for idx, row in df.iterrows(): | |
| if row['magnitude'] >= 6.0: | |
| color = 'red' | |
| radius = 15 | |
| elif row['magnitude'] >= 5.0: | |
| color = 'orange' | |
| radius = 12 | |
| elif row['magnitude'] >= 4.0: | |
| color = 'yellow' | |
| radius = 10 | |
| else: | |
| color = 'green' | |
| radius = 8 | |
| popup_content = f""" | |
| <b>Magnitude {row['magnitude']}</b><br> | |
| Location: {row['place']}<br> | |
| Time: {row['time'].strftime('%Y-%m-%d %H:%M:%S')}<br> | |
| Depth: {row['depth']:.1f} km<br> | |
| <a href="{row['url']}" target="_blank">USGS Details</a> | |
| """ | |
| folium.CircleMarker( | |
| location=[row['latitude'], row['longitude']], | |
| radius=radius, | |
| popup=popup_content, | |
| color=color, | |
| fill=True, | |
| fillOpacity=0.7 | |
| ).add_to(m) | |
| if region_bbox: | |
| folium.Rectangle( | |
| bounds=[[region_bbox[1], region_bbox[0]], [region_bbox[3], region_bbox[2]]], | |
| color='blue', | |
| weight=2, | |
| fillOpacity=0.1 | |
| ).add_to(m) | |
| return m | |
| def create_comprehensive_charts(df, analysis): | |
| """Create comprehensive visualization charts""" | |
| if df.empty: | |
| return [] | |
| charts = [] | |
| # Magnitude over time with trend - with error handling | |
| fig1 = go.Figure() | |
| fig1.add_trace(go.Scatter( | |
| x=df['time'], y=df['magnitude'], | |
| mode='markers', | |
| marker=dict( | |
| size=df['magnitude'] * 2, | |
| color=df['magnitude'], | |
| colorscale='Reds', | |
| showscale=True | |
| ), | |
| name='Earthquakes' | |
| )) | |
| # Only add trend line if we have enough data points (at least 2) | |
| if len(df) >= 2: | |
| try: | |
| z = np.polyfit(range(len(df)), df['magnitude'], 1) | |
| p = np.poly1d(z) | |
| fig1.add_trace(go.Scatter( | |
| x=df['time'], y=p(range(len(df))), | |
| mode='lines', | |
| name='Trend', | |
| line=dict(color='blue', dash='dash') | |
| )) | |
| except (np.linalg.LinAlgError, ValueError) as e: | |
| # If polynomial fitting fails, just show the scatter plot without trend | |
| st.warning(f"Trend analysis unavailable: {str(e)}") | |
| fig1.update_layout( | |
| title='Earthquake Magnitude Over Time with Trend', | |
| xaxis_title='Time', | |
| yaxis_title='Magnitude', | |
| height=400 | |
| ) | |
| charts.append(fig1) | |
| # Magnitude distribution histogram - only if we have data | |
| if len(df) > 0: | |
| fig2 = px.histogram( | |
| df, x='magnitude', nbins=min(20, len(df)), # Limit bins to data size | |
| title='Magnitude Distribution', | |
| labels={'magnitude': 'Magnitude', 'count': 'Frequency'} | |
| ) | |
| fig2.update_layout(height=400) | |
| charts.append(fig2) | |
| # Depth vs Magnitude scatter - only if we have data | |
| if len(df) > 0: | |
| fig3 = px.scatter( | |
| df, x='depth', y='magnitude', color='magnitude', | |
| title='Depth vs Magnitude Relationship', | |
| labels={'depth': 'Depth (km)', 'magnitude': 'Magnitude'} | |
| ) | |
| fig3.update_layout(height=400) | |
| charts.append(fig3) | |
| # Hourly distribution - only if we have the data | |
| if 'hourly_distribution' in analysis and len(analysis['hourly_distribution']) > 0: | |
| fig4 = px.bar( | |
| x=analysis['hourly_distribution'].index, | |
| y=analysis['hourly_distribution'].values, | |
| title='Earthquake Activity by Hour of Day', | |
| labels={'x': 'Hour', 'y': 'Count'} | |
| ) | |
| fig4.update_layout(height=400) | |
| charts.append(fig4) | |
| # Risk level distribution - only if we have the data | |
| if 'risk_distribution' in analysis and len(analysis['risk_distribution']) > 0: | |
| fig5 = px.pie( | |
| values=analysis['risk_distribution'].values, | |
| names=analysis['risk_distribution'].index, | |
| title='Risk Level Distribution' | |
| ) | |
| fig5.update_layout(height=400) | |
| charts.append(fig5) | |
| return charts | |
| def main(): | |
| st.set_page_config( | |
| page_title="🌍 QuakeGuard AI", | |
| page_icon="🌍", | |
| layout="wide", | |
| initial_sidebar_state="expanded" | |
| ) | |
| st.markdown(""" | |
| <style> | |
| .main-header { | |
| font-size: 3rem; | |
| font-weight: bold; | |
| text-align: center; | |
| color: #1f77b4; | |
| margin-bottom: 2rem; | |
| } | |
| .risk-high { color: #ff4444; font-weight: bold; } | |
| .risk-moderate { color: #ffaa00; font-weight: bold; } | |
| .risk-low { color: #44aa44; font-weight: bold; } | |
| .metric-card { | |
| background-color: #f0f2f6; | |
| padding: 1rem; | |
| border-radius: 0.5rem; | |
| border-left: 4px solid #1f77b4; | |
| color: #222 !important; | |
| } | |
| </style> | |
| """, unsafe_allow_html=True) | |
| st.markdown('<h1 class="main-header">🌍 Advanced Earthquake Warning System</h1>', unsafe_allow_html=True) | |
| st.markdown("### Real-time seismic monitoring with AI-powered risk assessment and emergency protocols") | |
| # Check if API key is configured | |
| if not get_groq_api_key(): | |
| st.stop() | |
| st.sidebar.header("⚙️ Configuration") | |
| region = st.sidebar.text_input( | |
| "🌍 Region (optional)", | |
| placeholder="e.g., California, Pakistan, Japan" | |
| ) | |
| col1, col2 = st.sidebar.columns(2) | |
| with col1: | |
| min_magnitude = st.slider("📏 Min Magnitude", 1.0, 7.0, 2.5, 0.1) | |
| with col2: | |
| hours = st.slider("⏰ Hours", 1, 168, 24) | |
| with st.sidebar.expander("🔧 Advanced Options"): | |
| show_detailed_analysis = st.checkbox("Detailed Analysis", value=True) | |
| show_ai_summary = st.checkbox("AI Summary", value=True) | |
| show_emergency_protocols = st.checkbox("Emergency Protocols", value=True) | |
| region_bboxes = { | |
| "California": [-125, 32, -114, 42], | |
| "Pakistan": [60, 23, 77, 37], | |
| "Japan": [129, 31, 146, 45], | |
| "Chile": [-75, -56, -66, -17], | |
| "Turkey": [25, 36, 45, 43], | |
| "Indonesia": [95, -11, 141, 6], | |
| "India": [68, 6, 97, 37], | |
| "Mexico": [-118, 14, -86, 33], | |
| "USA": [-125, 24, -66, 49], | |
| "World": [-180, -90, 180, 90] | |
| } | |
| region_bbox = region_bboxes.get(region.strip().title()) if region else None | |
| if st.button("🔄 Refresh Data", type="primary"): | |
| st.rerun() | |
| with st.spinner("🌐 Fetching earthquake data..."): | |
| df = fetch_earthquakes(min_magnitude, hours, region_bbox, show_detailed_analysis) | |
| if df.empty: | |
| st.warning("⚠️ No recent earthquakes found matching your criteria.") | |
| st.info("💡 Try reducing the minimum magnitude or increasing the time range.") | |
| # Show a simple message when no data is available | |
| st.markdown(""" | |
| <div class="metric-card"> | |
| <h3>🚨 Current Risk Level: <span class="risk-low">LOW</span></h3> | |
| <p><strong>Risk Score:</strong> 0/80</p> | |
| <p><strong>Emergency Protocol:</strong> Monitor situation. No immediate action required.</p> | |
| </div> | |
| """, unsafe_allow_html=True) | |
| # Show tabs with appropriate messages | |
| tab1, tab2, tab3, tab4, tab5 = st.tabs(["🗺️ Map", "📊 Analytics", "📋 Data", "🤖 AI Analysis", "🚨 Emergency"]) | |
| with tab1: | |
| st.subheader("🌍 Interactive Earthquake Map") | |
| st.info("No earthquake data available for map visualization") | |
| with tab2: | |
| st.subheader("📊 Advanced Analytics") | |
| st.info("No earthquake data available for analysis") | |
| with tab3: | |
| st.subheader("📋 Earthquake Data") | |
| st.info("No earthquake data available") | |
| with tab4: | |
| st.subheader("🤖 AI-Powered Analysis") | |
| if show_ai_summary: | |
| st.info("No earthquake data available for AI analysis") | |
| else: | |
| st.info("Enable AI Summary in Advanced Options to see AI analysis.") | |
| with tab5: | |
| st.subheader("🚨 Emergency Information") | |
| if show_emergency_protocols: | |
| st.markdown(""" | |
| ### 🚨 Emergency Response Protocols | |
| **Immediate Actions During Earthquake:** | |
| - Drop, Cover, and Hold On | |
| - Stay indoors if you're inside | |
| - Move to open area if you're outside | |
| - Stay away from windows, mirrors, and heavy objects | |
| **After Earthquake:** | |
| - Check for injuries and provide first aid | |
| - Check for gas leaks and electrical damage | |
| - Listen to emergency broadcasts | |
| - Be prepared for aftershocks | |
| **Emergency Contacts:** | |
| - Emergency Services: 911 (US) / 112 (EU) / 999 (UK) | |
| - USGS Earthquake Information: https://earthquake.usgs.gov | |
| - Local Emergency Management: Check your local government website | |
| """) | |
| st.markdown(""" | |
| ### 📊 Current Emergency Status | |
| - **Risk Level**: LOW | |
| - **Recommended Action**: Monitor situation. No immediate action required. | |
| - **Monitoring Required**: No | |
| """) | |
| else: | |
| st.info("Enable Emergency Protocols in Advanced Options to see emergency information.") | |
| else: | |
| st.success(f"✅ Found {len(df)} earthquakes in the last {hours} hours") | |
| st.write(f"🕐 Last updated: {datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S')} UTC") | |
| risk_level, risk_score = calculate_overall_risk(df) | |
| st.markdown(f""" | |
| <div class="metric-card"> | |
| <h3>🚨 Current Risk Level: <span class="risk-{risk_level}">{risk_level.upper()}</span></h3> | |
| <p><strong>Risk Score:</strong> {risk_score}</p> | |
| <p><strong>Emergency Protocol:</strong> {EMERGENCY_PROTOCOLS[risk_level]}</p> | |
| </div> | |
| """, unsafe_allow_html=True) | |
| col1, col2, col3, col4 = st.columns(4) | |
| with col1: | |
| st.metric("Total Earthquakes", len(df)) | |
| with col2: | |
| st.metric("Max Magnitude", f"{df['magnitude'].max():.1f}") | |
| with col3: | |
| st.metric("Avg Magnitude", f"{df['magnitude'].mean():.2f}") | |
| with col4: | |
| st.metric("Avg Depth", f"{df['depth'].mean():.1f} km") | |
| tab1, tab2, tab3, tab4, tab5 = st.tabs(["🗺️ Map", "📊 Analytics", "📋 Data", "🤖 AI Analysis", "🚨 Emergency"]) | |
| with tab1: | |
| st.subheader("🌍 Interactive Earthquake Map") | |
| if not df.empty: | |
| try: | |
| map_obj = create_advanced_map(df, region_bbox) | |
| if map_obj: | |
| st_folium(map_obj, width=800, height=500) | |
| else: | |
| st.info("Unable to create map visualization") | |
| except Exception as e: | |
| st.error(f"Error creating map: {str(e)}") | |
| st.info("Try adjusting your search criteria") | |
| else: | |
| st.info("No earthquake data available for map visualization") | |
| with tab2: | |
| st.subheader("📊 Advanced Analytics") | |
| if not df.empty: | |
| try: | |
| analysis = analyze_seismic_patterns(df) | |
| charts = create_comprehensive_charts(df, analysis) | |
| for i, chart in enumerate(charts): | |
| st.plotly_chart(chart, use_container_width=True) | |
| if analysis: | |
| col1, col2 = st.columns(2) | |
| with col1: | |
| st.subheader("📈 Magnitude Statistics") | |
| if 'magnitude_stats' in analysis: | |
| stats_df = pd.DataFrame([analysis['magnitude_stats']]).T | |
| stats_df.columns = ['Value'] | |
| st.dataframe(stats_df) | |
| else: | |
| st.info("Insufficient data for magnitude statistics") | |
| with col2: | |
| st.subheader("📊 Risk Distribution") | |
| if 'risk_distribution' in analysis and len(analysis['risk_distribution']) > 0: | |
| risk_df = pd.DataFrame(analysis['risk_distribution']) | |
| risk_df.columns = ['Count'] | |
| st.dataframe(risk_df) | |
| else: | |
| st.info("No risk distribution data available") | |
| except Exception as e: | |
| st.error(f"Error in analytics: {str(e)}") | |
| st.info("Try adjusting your search criteria or check your internet connection") | |
| else: | |
| st.info("No earthquake data available for analysis") | |
| with tab3: | |
| st.subheader("📋 Earthquake Data") | |
| if not df.empty: | |
| col1, col2 = st.columns(2) | |
| with col1: | |
| magnitude_filter = st.multiselect( | |
| "Filter by Magnitude Category", | |
| options=df['magnitude_category'].unique(), | |
| default=df['magnitude_category'].unique() | |
| ) | |
| with col2: | |
| risk_filter = st.multiselect( | |
| "Filter by Risk Level", | |
| options=df['risk_level'].unique(), | |
| default=df['risk_level'].unique() | |
| ) | |
| filtered_df = df[ | |
| (df['magnitude_category'].isin(magnitude_filter)) & | |
| (df['risk_level'].isin(risk_filter)) | |
| ] | |
| st.dataframe( | |
| filtered_df[['time', 'place', 'magnitude', 'depth', 'risk_level', 'time_ago', 'url']], | |
| use_container_width=True | |
| ) | |
| csv = filtered_df.to_csv(index=False) | |
| st.download_button( | |
| label="📥 Download CSV", | |
| data=csv, | |
| file_name=f"earthquakes_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv", | |
| mime="text/csv" | |
| ) | |
| with tab4: | |
| st.subheader("🤖 AI-Powered Analysis") | |
| if show_ai_summary and not df.empty: | |
| with st.spinner("🤖 Generating AI analysis..."): | |
| analysis = analyze_seismic_patterns(df) | |
| risk_level, risk_score = calculate_overall_risk(df) | |
| prompt = f""" | |
| As an expert seismologist and emergency response specialist, provide a comprehensive analysis of the following earthquake data: | |
| SUMMARY STATISTICS: | |
| - Total earthquakes: {len(df)} | |
| - Time period: {hours} hours | |
| - Magnitude range: {df['magnitude'].min():.1f} - {df['magnitude'].max():.1f} | |
| - Average magnitude: {df['magnitude'].mean():.2f} | |
| - Risk level: {risk_level.upper()} | |
| - Risk score: {risk_score} | |
| EARTHQUAKE DATA: | |
| {df[['time', 'place', 'magnitude', 'depth']].head(20).to_string(index=False)} | |
| Please provide: | |
| 1. **Risk Assessment**: Detailed evaluation of current seismic risk | |
| 2. **Pattern Analysis**: Identification of any concerning patterns or trends | |
| 3. **Regional Impact**: Specific implications for affected areas | |
| 4. **Safety Recommendations**: Detailed safety advice for the public | |
| 5. **Emergency Preparedness**: Specific actions people should take | |
| 6. **Monitoring Recommendations**: What to watch for in coming hours/days | |
| Be thorough, specific, and actionable in your response. | |
| """ | |
| summary = get_groq_summary(prompt) | |
| st.markdown(summary) | |
| else: | |
| st.info("Enable AI Summary in Advanced Options to see AI analysis.") | |
| with tab5: | |
| st.subheader("🚨 Emergency Information") | |
| if show_emergency_protocols: | |
| st.markdown(""" | |
| ### 🚨 Emergency Response Protocols | |
| **Immediate Actions During Earthquake:** | |
| - Drop, Cover, and Hold On | |
| - Stay indoors if you're inside | |
| - Move to open area if you're outside | |
| - Stay away from windows, mirrors, and heavy objects | |
| **After Earthquake:** | |
| - Check for injuries and provide first aid | |
| - Check for gas leaks and electrical damage | |
| - Listen to emergency broadcasts | |
| - Be prepared for aftershocks | |
| **Emergency Contacts:** | |
| - Emergency Services: 911 (US) / 112 (EU) / 999 (UK) | |
| - USGS Earthquake Information: https://earthquake.usgs.gov | |
| - Local Emergency Management: Check your local government website | |
| """) | |
| st.markdown(f""" | |
| ### 📊 Current Emergency Status | |
| - **Risk Level**: {risk_level.upper()} | |
| - **Recommended Action**: {EMERGENCY_PROTOCOLS[risk_level]} | |
| - **Monitoring Required**: {'Yes' if risk_level in ['high', 'severe', 'extreme'] else 'No'} | |
| """) | |
| else: | |
| st.info("Enable Emergency Protocols in Advanced Options to see emergency information.") | |
| if __name__ == "__main__": | |
| main() |