import gradio as gr import pandas as pd import numpy as np import tempfile import plotly.graph_objects as go import plotly.express as px from urllib.parse import urlencode from plotly.subplots import make_subplots import requests from datetime import datetime, timedelta import warnings import json warnings.filterwarnings('ignore') class EnhancedOceanClimateAgent: def __init__(self): self.anomaly_threshold = 2.0 self.critical_temp_change = 1.5 # Fixed NOAA API base URL self.noaa_base_url = "https://api.tidesandcurrents.noaa.gov/api/prod/datagetter" self.noaa_stations_url = "https://api.tidesandcurrents.noaa.gov/mdapi/prod/webapi/stations.json" # Popular NOAA stations for different regions self.default_stations = { "San Francisco, CA": "9414290", "New York, NY": "8518750", "Miami, FL": "8723214", "Seattle, WA": "9447130", "Boston, MA": "8443970", "Los Angeles, CA": "9410660", "Galveston, TX": "8771450", "Charleston, SC": "8665530" } def get_noaa_data(self, station_id, product, begin_date, end_date, units="metric"): """Fetch NOAA data for a given product and date range""" # Format dates for NOAA API begin_str = begin_date.strftime("%Y%m%d %H:%M") end_str = end_date.strftime("%Y%m%d %H:%M") params = { 'station': station_id, 'product': product, 'begin_date': begin_str, 'end_date': end_str, 'datum': 'MLLW', # Mean Lower Low Water 'application': 'OceanClimateAgent', 'time_zone': 'gmt', 'units': units, 'format': 'json' } try: print(f"Fetching {product} data for station {station_id}") print(f"Date range: {begin_str} to {end_str}") response = requests.get(self.noaa_base_url, params=params, timeout=30) if response.status_code != 200: print(f"HTTP Error {response.status_code}: {response.text}") return None data = response.json() if 'data' in data and data['data']: print(f"Successfully fetched {len(data['data'])} records for {product}") return pd.DataFrame(data['data']) elif 'error' in data: print(f"NOAA API error for {product}: {data['error']['message']}") return None else: print(f"No data returned for {product}") return None except requests.exceptions.Timeout: print(f"Timeout fetching {product} data") return None except requests.exceptions.RequestException as e: print(f"Request failed for {product}: {str(e)}") return None except json.JSONDecodeError as e: print(f"JSON decode error for {product}: {str(e)}") return None except Exception as e: print(f"Unexpected error fetching {product}: {str(e)}") return None def get_comprehensive_station_data(self, station_name, days_back=30): """Get comprehensive data from a NOAA station""" station_id = self.default_stations.get(station_name) if not station_id: return None, "Station not found" # Ensure end_date is not in the future and allow for some buffer end_date = datetime.utcnow() - timedelta(hours=2) # 2 hour buffer start_date = end_date - timedelta(days=days_back) print(f"Fetching data for {station_name} (ID: {station_id})") print(f"Date range: {start_date} to {end_date}") # Priority order - start with most reliable products products_to_fetch = [ ('water_level', 'water_level'), ('water_temperature', 'water_temperature'), ('air_temperature', 'air_temperature'), ('wind', 'wind'), ('air_pressure', 'air_pressure') ] all_data = {} success_count = 0 for product_name, product_code in products_to_fetch: print(f"Attempting to fetch {product_name}...") data = self.get_noaa_data(station_id, product_code, start_date, end_date) if data is not None and not data.empty: all_data[product_name] = data success_count += 1 print(f"{product_name}: {len(data)} records") else: print(f"{product_name}: No data available") if success_count == 0: return None, f"No data available for station {station_name} in the specified time period. This could be due to: station maintenance, data processing delays, or the station may not support the requested data types." print(f"Successfully retrieved {success_count}/{len(products_to_fetch)} data types") return all_data, f"Successfully retrieved {success_count}/{len(products_to_fetch)} data types" def process_noaa_data(self, raw_data): """Process and combine NOAA data for analysis""" if not raw_data: return None base_df = None # Start with water level data if available (most common) if 'water_level' in raw_data: df = raw_data['water_level'].copy() df['datetime'] = pd.to_datetime(df['t']) df['water_level'] = pd.to_numeric(df['v'], errors='coerce') base_df = df[['datetime', 'water_level']].copy() print(f"Base dataset: water_level with {len(base_df)} records") # If no water level, try other datasets if base_df is None: for product_name in ['water_temperature', 'air_temperature', 'wind', 'air_pressure']: if product_name in raw_data: df = raw_data[product_name].copy() df['datetime'] = pd.to_datetime(df['t']) if product_name == 'wind': df['wind_speed'] = pd.to_numeric(df['s'], errors='coerce') base_df = df[['datetime', 'wind_speed']].copy() else: column_name = product_name.replace('_temperature', '_temp') df[column_name] = pd.to_numeric(df['v'], errors='coerce') base_df = df[['datetime', column_name]].copy() print(f"Base dataset: {product_name} with {len(base_df)} records") break if base_df is None: return None # Add other parameters when available if 'water_temperature' in raw_data and 'water_temp' not in base_df.columns: temp_df = raw_data['water_temperature'].copy() temp_df['datetime'] = pd.to_datetime(temp_df['t']) temp_df['water_temp'] = pd.to_numeric(temp_df['v'], errors='coerce') base_df = base_df.merge(temp_df[['datetime', 'water_temp']], on='datetime', how='outer') if 'air_temperature' in raw_data and 'air_temp' not in base_df.columns: air_temp_df = raw_data['air_temperature'].copy() air_temp_df['datetime'] = pd.to_datetime(air_temp_df['t']) air_temp_df['air_temp'] = pd.to_numeric(air_temp_df['v'], errors='coerce') base_df = base_df.merge(air_temp_df[['datetime', 'air_temp']], on='datetime', how='outer') if 'wind' in raw_data and 'wind_speed' not in base_df.columns: wind_df = raw_data['wind'].copy() wind_df['datetime'] = pd.to_datetime(wind_df['t']) wind_df['wind_speed'] = pd.to_numeric(wind_df['s'], errors='coerce') wind_df['wind_direction'] = pd.to_numeric(wind_df['d'], errors='coerce') base_df = base_df.merge(wind_df[['datetime', 'wind_speed', 'wind_direction']], on='datetime', how='outer') if 'air_pressure' in raw_data and 'air_pressure' not in base_df.columns: pressure_df = raw_data['air_pressure'].copy() pressure_df['datetime'] = pd.to_datetime(pressure_df['t']) pressure_df['air_pressure'] = pd.to_numeric(pressure_df['v'], errors='coerce') base_df = base_df.merge(pressure_df[['datetime', 'air_pressure']], on='datetime', how='outer') # Sort by datetime and remove duplicates base_df = base_df.sort_values('datetime').drop_duplicates(subset=['datetime']) print(f"Final processed dataset: {len(base_df)} records with {len(base_df.columns)-1} parameters") return base_df def detect_anomalies(self, data, column, window=24): # 24 hours for hourly data """Detect anomalies using rolling statistics""" if column not in data.columns or data[column].isna().all(): return pd.Series([False] * len(data)), pd.Series([0] * len(data)) rolling_mean = data[column].rolling(window=window, center=True, min_periods=1).mean() rolling_std = data[column].rolling(window=window, center=True, min_periods=1).std() # Avoid division by zero rolling_std = rolling_std.fillna(1) rolling_std = rolling_std.replace(0, 1) z_scores = np.abs((data[column] - rolling_mean) / rolling_std) anomalies = z_scores > self.anomaly_threshold return anomalies, z_scores def calculate_trends(self, data, column, hours=168): # 7 days """Calculate trend over specified period""" if column not in data.columns or data[column].isna().all(): return 0 recent_data = data.tail(hours) if len(recent_data) < 2: return 0 x = np.arange(len(recent_data)) y = recent_data[column].dropna() if len(y) < 2: return 0 x = x[:len(y)] slope = np.polyfit(x, y, 1)[0] if len(x) > 1 else 0 return slope def generate_climate_analysis(self, data, station_name): """Generate comprehensive climate analysis""" if data is None or data.empty: return {}, [] analysis = {} alerts = [] # Water level analysis if 'water_level' in data.columns: wl_trend = self.calculate_trends(data, 'water_level') analysis['water_level_trend'] = wl_trend * 24 # per day if abs(wl_trend * 24) > 5: # >5cm per day change alerts.append(f"Significant water level change: {wl_trend*24:.1f}cm/day at {station_name}") # Temperature analysis for temp_col in ['water_temp', 'air_temp']: if temp_col in data.columns: temp_trend = self.calculate_trends(data, temp_col) analysis[f'{temp_col}_trend'] = temp_trend * 24 # per day if temp_trend * 24 > 0.5: # >0.5°C per day alerts.append(f"Rapid {temp_col.replace('_', ' ')} rise: {temp_trend*24:.2f}°C/day at {station_name}") # Anomaly detection for col in ['water_level', 'water_temp', 'air_temp', 'wind_speed']: if col in data.columns: anomalies, z_scores = self.detect_anomalies(data, col) anomaly_pct = (anomalies.sum() / len(data)) * 100 analysis[f'{col}_anomaly_frequency'] = anomaly_pct if anomaly_pct > 10: alerts.append(f"High {col.replace('_', ' ')} anomaly frequency: {anomaly_pct:.1f}% at {station_name}") if not alerts: alerts.append(f"No significant anomalies detected at {station_name}") return analysis, alerts # Initialize the enhanced agent agent = EnhancedOceanClimateAgent() def analyze_real_ocean_data(station_name, days_back, anomaly_sensitivity, use_real_data): """Main analysis function with real NOAA data""" agent.anomaly_threshold = anomaly_sensitivity if use_real_data: print(f"Starting real data analysis for {station_name}") # Fetch real NOAA data raw_data, status_msg = agent.get_comprehensive_station_data(station_name, days_back) if raw_data is None: error_msg = f"Error fetching real data: {status_msg}" print(error_msg) return None, None, None, error_msg, "No alerts - data unavailable", None # Process the data data = agent.process_noaa_data(raw_data) if data is None or data.empty: error_msg = "No processable data available after fetching from NOAA" print(error_msg) return None, None, None, error_msg, "No alerts - data unavailable", None data_source = f"Real NOAA data from {station_name} ({status_msg})" print(f"{data_source}") else: print("🔧 Using synthetic demonstration data") # Use synthetic data for demonstration data = generate_synthetic_data(days_back) data_source = f"🔧 Synthetic demonstration data ({days_back} days)" # Generate analysis and alerts analysis, alerts = agent.generate_climate_analysis(data, station_name) # Create visualizations fig1 = create_main_dashboard(data, agent) fig2 = create_anomaly_plots(data, agent) fig3 = create_correlation_plot(data) # Format analysis text analysis_text = format_analysis_results(analysis, data_source) alerts_text = "\n".join([f"- {alert}" for alert in alerts]) # Create CSV for download csv_file_path = save_csv_temp(data) print("Analysis completed successfully") return fig1, fig2, fig3, analysis_text, alerts_text, csv_file_path def generate_synthetic_data(days): """Generate synthetic data for demonstration""" dates = pd.date_range(start=datetime.now() - timedelta(days=days), periods=days*24, freq='H') # Synthetic water level with tidal patterns tidal_pattern = 2 * np.sin(2 * np.pi * np.arange(len(dates)) / 12.42) # M2 tide water_level = 100 + tidal_pattern + np.random.normal(0, 0.3, len(dates)) # Water temperature with daily cycle daily_temp_cycle = 2 * np.sin(2 * np.pi * np.arange(len(dates)) / 24) water_temp = 15 + daily_temp_cycle + np.random.normal(0, 0.5, len(dates)) # Wind patterns wind_speed = 5 + 3 * np.sin(2 * np.pi * np.arange(len(dates)) / (24*3)) + np.random.normal(0, 1, len(dates)) wind_direction = 180 + 45 * np.sin(2 * np.pi * np.arange(len(dates)) / (24*2)) + np.random.normal(0, 20, len(dates)) return pd.DataFrame({ 'datetime': dates, 'water_level': water_level, 'water_temp': water_temp, 'wind_speed': np.maximum(0, wind_speed), 'wind_direction': wind_direction % 360, 'air_pressure': 1013 + np.random.normal(0, 10, len(dates)) }) def create_main_dashboard(data, agent): """Create main dashboard visualization""" available_plots = [] plot_data = [] # Check what data is available if 'water_level' in data.columns and not data['water_level'].isna().all(): available_plots.append(('Water Level', 'water_level', 'blue')) if 'water_temp' in data.columns and not data['water_temp'].isna().all(): available_plots.append(('Water Temperature', 'water_temp', 'red')) if 'air_temp' in data.columns and not data['air_temp'].isna().all(): available_plots.append(('Air Temperature', 'air_temp', 'orange')) if 'wind_speed' in data.columns and not data['wind_speed'].isna().all(): available_plots.append(('Wind Speed', 'wind_speed', 'green')) if 'air_pressure' in data.columns and not data['air_pressure'].isna().all(): available_plots.append(('Air Pressure', 'air_pressure', 'purple')) if not available_plots: fig = go.Figure() fig.add_annotation(text="No data available for visualization", xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False) return fig # Create subplots based on available data n_plots = len(available_plots) rows = (n_plots + 1) // 2 # Ceiling division cols = 2 if n_plots > 1 else 1 fig = make_subplots( rows=rows, cols=cols, subplot_titles=[plot[0] for plot in available_plots], vertical_spacing=0.1 ) for i, (title, column, color) in enumerate(available_plots): row = (i // 2) + 1 col = (i % 2) + 1 # Add main data line fig.add_trace( go.Scatter(x=data['datetime'], y=data[column], name=title, line=dict(color=color)), row=row, col=col ) # Add anomalies if applicable anomalies, _ = agent.detect_anomalies(data, column) if anomalies.any(): anomaly_data = data[anomalies] fig.add_trace( go.Scatter(x=anomaly_data['datetime'], y=anomaly_data[column], mode='markers', name=f'{title} Anomalies', marker=dict(color='red', size=6)), row=row, col=col ) fig.update_layout(height=300*rows, showlegend=False, title_text="Ocean and Atmospheric Data Dashboard") return fig def create_anomaly_plots(data, agent): """Create anomaly detection plots""" available_cols = [col for col in ['water_level', 'water_temp', 'air_temp', 'wind_speed'] if col in data.columns and not data[col].isna().all()] if len(available_cols) == 0: fig = go.Figure() fig.add_annotation(text="No data available for anomaly detection", xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False) return fig n_plots = min(len(available_cols), 2) # Maximum 2 plots fig = make_subplots( rows=1, cols=n_plots, subplot_titles=[f'{col.replace("_", " ").title()} Anomalies' for col in available_cols[:n_plots]] ) colors = ['blue', 'red', 'green', 'purple'] for i, col in enumerate(available_cols[:n_plots]): _, z_scores = agent.detect_anomalies(data, col) fig.add_trace( go.Scatter(x=data['datetime'], y=z_scores, mode='lines', name=f'{col} Z-Score', line=dict(color=colors[i % len(colors)])), row=1, col=i+1 ) fig.add_hline(y=agent.anomaly_threshold, line_dash="dash", line_color="red", row=1, col=i+1) fig.update_layout(height=400, showlegend=False, title_text="Anomaly Detection Analysis") return fig def create_correlation_plot(data): """Create correlation heatmap""" numeric_cols = [col for col in ['water_level', 'water_temp', 'air_temp', 'wind_speed', 'air_pressure'] if col in data.columns and not data[col].isna().all()] if len(numeric_cols) < 2: # Return empty plot if insufficient data fig = go.Figure() fig.add_annotation(text="Insufficient data for correlation analysis", xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False) return fig corr_matrix = data[numeric_cols].corr() fig = px.imshow(corr_matrix, labels=dict(color="Correlation"), color_continuous_scale='RdBu_r', aspect="auto", title="Parameter Correlations") return fig def format_analysis_results(analysis, data_source): """Format analysis results for display""" result = f"### {data_source}\n\n**Key Trends:**\n" if not analysis: result += "- No analysis data available\n" return result for key, value in analysis.items(): if 'trend' in key: param = key.replace('_trend', '').replace('_', ' ').title() unit = 'cm/day' if 'water_level' in key else '°C/day' if 'temp' in key else 'units/day' result += f"- {param}: {value:.3f} {unit}\n" elif 'anomaly_frequency' in key: param = key.replace('_anomaly_frequency', '').replace('_', ' ').title() result += f"- {param} anomalies: {value:.1f}%\n" return result def save_csv_temp(data): """Save data to temporary CSV file""" tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".csv", mode='w', newline='', encoding='utf-8') data.to_csv(tmp.name, index=False) tmp.close() return tmp.name # Create Gradio interface with gr.Blocks(title="Enhanced Ocean Climate Monitoring AI Agent", theme=gr.themes.Ocean()) as demo: gr.Markdown(""" # Enhanced Ocean Climate Monitoring AI Agent ### Real-time Analysis with NOAA Data Integration This enhanced AI agent can fetch real ocean data from NOAA stations or use synthetic data for demonstration. Monitor water levels, temperature, currents, and detect climate anomalies at major coastal locations. **Note:** NOAA stations may not have all data types available. The system will use whatever data is accessible. """) with gr.Row(): with gr.Column(scale=1): gr.Markdown("### Configuration") station_name = gr.Dropdown( choices=list(agent.default_stations.keys()), value="San Francisco, CA", label="NOAA Station Location" ) days_back = gr.Slider( minimum=1, maximum=30, value=7, step=1, label="Days of Historical Data", info="Shorter periods are more reliable" ) anomaly_sensitivity = gr.Slider( minimum=1.0, maximum=3.0, value=2.0, step=0.1, label="Anomaly Detection Sensitivity" ) use_real_data = gr.Checkbox( label="Use Real NOAA Data", value=True, info="Uncheck to use synthetic data" ) analyze_btn = gr.Button("Analyze Ocean Data", variant="primary") with gr.Column(scale=2): gr.Markdown("### Climate Alerts") alerts_output = gr.Markdown() with gr.Row(): analysis_output = gr.Markdown() with gr.Tab("Main Dashboard"): dashboard_plot = gr.Plot() with gr.Tab("Anomaly Detection"): anomaly_plot = gr.Plot() with gr.Tab("Correlations"): correlation_plot = gr.Plot() with gr.Tab("Data Export"): gr.Markdown("### Download Analyzed Data") csv_output = gr.File(label="Download CSV Data") gr.Markdown("*Note: Real NOAA data usage is subject to their terms of service*") # Set up the analysis function analyze_btn.click( fn=analyze_real_ocean_data, inputs=[station_name, days_back, anomaly_sensitivity, use_real_data], outputs=[dashboard_plot, anomaly_plot, correlation_plot, analysis_output, alerts_output, csv_output] ) # Auto-run on startup with synthetic data demo.load( fn=analyze_real_ocean_data, inputs=[ gr.Text(value="San Francisco, CA", visible=False), gr.Number(value=7, visible=False), gr.Number(value=2.0, visible=False), gr.Checkbox(value=False, visible=False) # Start with synthetic data ], outputs=[dashboard_plot, anomaly_plot, correlation_plot, analysis_output, alerts_output, csv_output] ) if __name__ == "__main__": demo.launch()