Update app.py

app.py

@@ -17,8 +17,8 @@ class EnhancedOceanClimateAgent:
         self.anomaly_threshold = 2.0
         self.critical_temp_change = 1.5
 
-        #https://api.tidesandcurrents.noaa.gov/api/prod/datagetter
-        self.noaa_base_url = "https://api.tidesandcurrents.noaa.gov/api/prod/datagetter?date=latest&product=water_level&time_zone=gmt&units=english&format=xml"
+        # 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
@@ -33,47 +33,58 @@ class EnhancedOceanClimateAgent:
             "Charleston, SC": "8665530"
         }
     
-    def get_noaa_data(self, station_id, product, start_date, end_date, units="metric"):
-        """Fetch data from NOAA API"""
+    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',
-            'begin_date': start_date.strftime('%Y%m%d'),
-            'end_date': end_date.strftime('%Y%m%d'),
-            'station': station_id,
             'time_zone': 'gmt',
             'units': units,
             'format': 'json'
         }
-    
+        
         try:
-            print(f"📡 Requesting {product} data for station {station_id}")
-            print("🕐 Date range:", start_date.strftime('%Y-%m-%d'), "to", end_date.strftime('%Y-%m-%d'))
-
-            # Print full API URL for testing
-            full_url = f"{self.noaa_base_url}?{urlencode(params)}"
-            print(f"🌐 NOAA API URL: {full_url}")
-    
+            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)
-            print(f"🔁 Status code: {response.status_code}")
-    
-            if response.status_code == 200:
-                data = response.json()
-                if 'data' in data:
-                    print(f"✅ Data received: {len(data['data'])} records for {product}")
-                    return pd.DataFrame(data['data'])
-                elif 'error' in data:
-                    print(f"❌ NOAA error: {data['error'].get('message')}")
-                else:
-                    print(f"❌ Unknown response structure: {data}")
+            
+            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"❌ API HTTP error {response.status_code}: {response.text}")
-    
-        except Exception as e:
+                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
-
+            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"""
@@ -81,35 +92,40 @@ class EnhancedOceanClimateAgent:
         if not station_id:
             return None, "Station not found"
         
-        # Ensure end_date is not in the future (NOAA does not support future data)
-        today = datetime.utcnow().replace(hour=0, minute=0, second=0, microsecond=0)
-        end_date = min(datetime.utcnow(), today)
+        # 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)
-
         
-        # Available NOAA products
-        products_to_fetch = {
-            'water_level': 'water_level',
-            'water_temperature': 'water_temperature', 
-            'air_temperature': 'air_temperature',
-            'wind': 'wind',
-            'air_pressure': 'air_pressure',
-            'salinity': 'salinity',
-            'currents': 'currents'
-        }
+        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.items():
+        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, "No data available for this station and time period"
+            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):
@@ -117,47 +133,66 @@ class EnhancedOceanClimateAgent:
         if not raw_data:
             return None
         
-        # Process water level data (primary dataset)
+        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')
-            
-            # Add other parameters when available
-            if 'water_temperature' in raw_data:
-                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')
-                df = df.merge(temp_df[['datetime', 'water_temp']], on='datetime', how='left')
-            
-            if 'air_temperature' in raw_data:
-                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')
-                df = df.merge(air_temp_df[['datetime', 'air_temp']], on='datetime', how='left')
-            
-            if 'wind' in raw_data:
-                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')
-                df = df.merge(wind_df[['datetime', 'wind_speed', 'wind_direction']], on='datetime', how='left')
-            
-            if 'air_pressure' in raw_data:
-                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')
-                df = df.merge(pressure_df[['datetime', 'air_pressure']], on='datetime', how='left')
-            
-            if 'salinity' in raw_data:
-                salinity_df = raw_data['salinity'].copy()
-                salinity_df['datetime'] = pd.to_datetime(salinity_df['t'])
-                salinity_df['salinity'] = pd.to_numeric(salinity_df['v'], errors='coerce')
-                df = df.merge(salinity_df[['datetime', 'salinity']], on='datetime', how='left')
-            
-            return df
+            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')
         
-        return None
+        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"""
@@ -212,15 +247,16 @@ class EnhancedOceanClimateAgent:
                 alerts.append(f"Significant water level change: {wl_trend*24:.1f}cm/day at {station_name}")
         
         # Temperature analysis
-        if 'water_temp' in data.columns:
-            temp_trend = self.calculate_trends(data, 'water_temp')
-            analysis['water_temp_trend'] = temp_trend * 24  # per day
-            
-            if temp_trend * 24 > 0.5:  # >0.5°C per day
-                alerts.append(f"Rapid water temperature rise: {temp_trend*24:.2f}°C/day at {station_name}")
+        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', 'wind_speed']:
+        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
@@ -243,24 +279,31 @@ def analyze_real_ocean_data(station_name, days_back, anomaly_sensitivity, use_re
     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:
-            return None, None, None, f"Error: {status_msg}", "No alerts - data unavailable", 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:
-            return None, None, None, "No processable data available", "No alerts - data unavailable", None
+            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})"
+        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)"
+        data_source = f"🔧 Synthetic demonstration data ({days_back} days)"
     
     # Generate analysis and alerts
     analysis, alerts = agent.generate_climate_analysis(data, station_name)
@@ -275,17 +318,9 @@ def analyze_real_ocean_data(station_name, days_back, anomaly_sensitivity, use_re
     alerts_text = "\n".join([f"- {alert}" for alert in alerts])
     
     # Create CSV for download
-    import tempfile
-
-    #Create CSV
-    def save_csv_temp(data):
-        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
-
-    
     csv_file_path = save_csv_temp(data)
+    
+    print("✅ Analysis completed successfully")
     return fig1, fig2, fig3, analysis_text, alerts_text, csv_file_path
 
 
@@ -316,92 +351,100 @@ def generate_synthetic_data(days):
 
 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=2, cols=2,
-        subplot_titles=('Water Level', 'Water Temperature', 'Wind Speed', 'Air Pressure'),
+        rows=rows, cols=cols,
+        subplot_titles=[plot[0] for plot in available_plots],
         vertical_spacing=0.1
     )
     
-    # Water Level
-    if 'water_level' in data.columns:
+    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['water_level'], 
-                      name='Water Level', line=dict(color='blue')),
-            row=1, col=1
+            go.Scatter(x=data['datetime'], y=data[column], 
+                      name=title, line=dict(color=color)),
+            row=row, col=col
         )
         
-        # Add anomalies
-        anomalies, _ = agent.detect_anomalies(data, 'water_level')
+        # 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['water_level'],
-                          mode='markers', name='Anomalies', 
+                go.Scatter(x=anomaly_data['datetime'], y=anomaly_data[column],
+                          mode='markers', name=f'{title} Anomalies', 
                           marker=dict(color='red', size=6)),
-                row=1, col=1
+                row=row, col=col
             )
     
-    # Water Temperature
-    if 'water_temp' in data.columns:
-        fig.add_trace(
-            go.Scatter(x=data['datetime'], y=data['water_temp'], 
-                      name='Water Temp', line=dict(color='red')),
-            row=1, col=2
-        )
-    
-    # Wind Speed
-    if 'wind_speed' in data.columns:
-        fig.add_trace(
-            go.Scatter(x=data['datetime'], y=data['wind_speed'], 
-                      name='Wind Speed', line=dict(color='green')),
-            row=2, col=1
-        )
-    
-    # Air Pressure
-    if 'air_pressure' in data.columns:
-        fig.add_trace(
-            go.Scatter(x=data['datetime'], y=data['air_pressure'], 
-                      name='Air Pressure', line=dict(color='purple')),
-            row=2, col=2
-        )
-    
-    fig.update_layout(height=600, showlegend=False, title_text="Ocean and Atmospheric Data Dashboard")
+    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=2,
-        subplot_titles=('Water Level Anomalies', 'Temperature Anomalies')
+        rows=1, cols=n_plots,
+        subplot_titles=[f'{col.replace("_", " ").title()} Anomalies' for col in available_cols[:n_plots]]
     )
     
-    # Water level anomalies
-    if 'water_level' in data.columns:
-        _, z_scores = agent.detect_anomalies(data, 'water_level')
-        fig.add_trace(
-            go.Scatter(x=data['datetime'], y=z_scores, 
-                      mode='lines', name='Water Level Z-Score'),
-            row=1, col=1
-        )
-        fig.add_hline(y=agent.anomaly_threshold, line_dash="dash", line_color="red", row=1, col=1)
+    colors = ['blue', 'red', 'green', 'purple']
     
-    # Temperature anomalies
-    if 'water_temp' in data.columns:
-        _, z_scores = agent.detect_anomalies(data, 'water_temp')
+    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='Temperature Z-Score', line=dict(color='red')),
-            row=1, col=2
+                      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=2)
+        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', 'wind_speed', 'air_pressure'] 
-                   if col in data.columns]
+    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
@@ -423,6 +466,10 @@ 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()
@@ -434,6 +481,13 @@ def format_analysis_results(analysis, data_source):
     
     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("""
@@ -442,6 +496,8 @@ with gr.Blocks(title="Enhanced Ocean Climate Monitoring AI Agent", theme=gr.them
     
     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():
@@ -453,11 +509,12 @@ with gr.Blocks(title="Enhanced Ocean Climate Monitoring AI Agent", theme=gr.them
                 label="NOAA Station Location"
             )
             days_back = gr.Slider(
-                minimum=7, 
-                maximum=90, 
-                value=30, 
+                minimum=1, 
+                maximum=30, 
+                value=7, 
                 step=1,
-                label="Days of Historical Data"
+                label="Days of Historical Data",
+                info="Shorter periods are more reliable"
             )
             anomaly_sensitivity = gr.Slider(
                 minimum=1.0, 
@@ -506,7 +563,7 @@ with gr.Blocks(title="Enhanced Ocean Climate Monitoring AI Agent", theme=gr.them
         fn=analyze_real_ocean_data,
         inputs=[
             gr.Text(value="San Francisco, CA", visible=False),
-            gr.Number(value=30, 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
         ],