Update app.py

app.py

@@ -1388,15 +1388,30 @@ def categorize_typhoon_by_standard(wind_speed, standard='atlantic'):
 # -----------------------------
 
 def get_available_years(typhoon_data):
-    """Get all available years including 2025"""
-    if 'ISO_TIME' in typhoon_data.columns:
-        years = typhoon_data['ISO_TIME'].dt.year.unique()
-    elif 'SEASON' in typhoon_data.columns:
-        years = typhoon_data['SEASON'].unique()
-    else:
-        years = range(1980, 2026)  # Default range including 2025
-    
-    return sorted([str(year) for year in years if not pd.isna(year)])
+    """Get all available years including 2025 - with error handling"""
+    try:
+        if typhoon_data is None or typhoon_data.empty:
+            return [str(year) for year in range(2000, 2026)]
+            
+        if 'ISO_TIME' in typhoon_data.columns:
+            years = typhoon_data['ISO_TIME'].dt.year.dropna().unique()
+        elif 'SEASON' in typhoon_data.columns:
+            years = typhoon_data['SEASON'].dropna().unique()
+        else:
+            years = range(2000, 2026)  # Default range including 2025
+        
+        # Convert to strings and sort
+        year_strings = sorted([str(int(year)) for year in years if not pd.isna(year)])
+        
+        # Ensure we have at least some years
+        if not year_strings:
+            return [str(year) for year in range(2000, 2026)]
+            
+        return year_strings
+        
+    except Exception as e:
+        print(f"Error in get_available_years: {e}")
+        return [str(year) for year in range(2000, 2026)]
 
 def update_typhoon_options_enhanced(year, basin):
     """Enhanced typhoon options with TD support and 2025 data"""
@@ -1663,8 +1678,24 @@ initialize_data()
 # -----------------------------
 
 def create_interface():
-    """Create the enhanced Gradio interface"""
+    """Create the enhanced Gradio interface with robust error handling"""
     try:
+        # Ensure data is available
+        if oni_data is None or typhoon_data is None or merged_data is None:
+            logging.warning("Data not properly loaded, creating minimal interface")
+            return create_minimal_fallback_interface()
+            
+        # Get safe data statistics
+        try:
+            total_storms = len(typhoon_data['SID'].unique()) if 'SID' in typhoon_data.columns else 0
+            total_records = len(typhoon_data)
+            available_years = get_available_years(typhoon_data)
+            year_range_display = f"{available_years[0]} - {available_years[-1]}" if available_years else "Unknown"
+        except Exception as e:
+            logging.error(f"Error getting data statistics: {e}")
+            total_storms = 0
+            total_records = 0
+            year_range_display = "Unknown"
         with gr.Blocks(title="Enhanced Typhoon Analysis Platform", theme=gr.themes.Soft()) as demo:
             gr.Markdown("# 🌪️ Enhanced Typhoon Analysis Platform")
             gr.Markdown("Advanced ML clustering, CNN predictions, and comprehensive tropical cyclone analysis including Tropical Depressions")
@@ -1684,9 +1715,9 @@ def create_interface():
                 
                 ### 📁 Data Status:
                 - **ONI Data**: {len(oni_data)} years loaded
-                - **Typhoon Data**: {len(typhoon_data)} records loaded
+                - **Typhoon Data**: {total_records} records loaded
                 - **Merged Data**: {len(merged_data)} typhoons with ONI values
-                - **Available Years**: {get_available_years(typhoon_data)[0]} - {get_available_years(typhoon_data)[-1]}
+                - **Available Years**: {year_range_display}
                 
                 ### 🔧 Technical Capabilities:
                 - **UMAP Clustering**: {"✅ Available" if UMAP_AVAILABLE else "❌ Limited to t-SNE/PCA"}
@@ -1871,8 +1902,8 @@ def create_interface():
                 with gr.Row():
                     year_dropdown = gr.Dropdown(
                         label="Year",
-                        choices=get_available_years(typhoon_data),
-                        value="2024"
+                        choices=available_years,
+                        value=available_years[-1] if available_years else "2024"
                     )
                     basin_dropdown = gr.Dropdown(
                         label="Basin",
@@ -1984,26 +2015,41 @@ def create_interface():
                 total_records = len(typhoon_data)
                 
                 if 'SEASON' in typhoon_data.columns:
-                    year_range = f"{typhoon_data['SEASON'].min():.0f}-{typhoon_data['SEASON'].max():.0f}"
-                    years_covered = typhoon_data['SEASON'].nunique()
+                    try:
+                        min_year = int(typhoon_data['SEASON'].min())
+                        max_year = int(typhoon_data['SEASON'].max())
+                        year_range = f"{min_year}-{max_year}"
+                        years_covered = typhoon_data['SEASON'].nunique()
+                    except (ValueError, TypeError):
+                        year_range = "Unknown"
+                        years_covered = 0
                 else:
                     year_range = "Unknown"
                     years_covered = 0
                 
                 if 'SID' in typhoon_data.columns:
-                    basins_available = ', '.join(sorted(typhoon_data['SID'].str[:2].unique()))
-                    avg_storms_per_year = total_storms / max(years_covered, 1)
+                    try:
+                        basins_available = ', '.join(sorted(typhoon_data['SID'].str[:2].unique()))
+                        avg_storms_per_year = total_storms / max(years_covered, 1)
+                    except Exception:
+                        basins_available = "Unknown"
+                        avg_storms_per_year = 0
                 else:
                     basins_available = "Unknown"
                     avg_storms_per_year = 0
                 
                 # TD specific statistics
-                if 'USA_WIND' in typhoon_data.columns:
-                    td_storms = len(typhoon_data[typhoon_data['USA_WIND'] < 34]['SID'].unique())
-                    ts_storms = len(typhoon_data[(typhoon_data['USA_WIND'] >= 34) & (typhoon_data['USA_WIND'] < 64)]['SID'].unique())
-                    typhoon_storms = len(typhoon_data[typhoon_data['USA_WIND'] >= 64]['SID'].unique())
-                    td_percentage = (td_storms / max(total_storms, 1)) * 100
-                else:
+                try:
+                    if 'USA_WIND' in typhoon_data.columns:
+                        td_storms = len(typhoon_data[typhoon_data['USA_WIND'] < 34]['SID'].unique())
+                        ts_storms = len(typhoon_data[(typhoon_data['USA_WIND'] >= 34) & (typhoon_data['USA_WIND'] < 64)]['SID'].unique())
+                        typhoon_storms = len(typhoon_data[typhoon_data['USA_WIND'] >= 64]['SID'].unique())
+                        td_percentage = (td_storms / max(total_storms, 1)) * 100
+                    else:
+                        td_storms = ts_storms = typhoon_storms = 0
+                        td_percentage = 0
+                except Exception as e:
+                    print(f"Error calculating TD statistics: {e}")
                     td_storms = ts_storms = typhoon_storms = 0
                     td_percentage = 0
                 
@@ -2039,12 +2085,66 @@ def create_interface():
         return demo
     except Exception as e:
         logging.error(f"Error creating Gradio interface: {e}")
+        import traceback
+        traceback.print_exc()
         # Create a minimal fallback interface
-        with gr.Blocks() as demo:
-            gr.Markdown("# 🌪️ Enhanced Typhoon Analysis Platform")
-            gr.Markdown("**Error**: Could not load full interface. Please check logs.")
-            gr.Markdown(f"Error details: {str(e)}")
-        return demo
+        return create_minimal_fallback_interface()
+
+def create_minimal_fallback_interface():
+    """Create a minimal fallback interface when main interface fails"""
+    with gr.Blocks() as demo:
+        gr.Markdown("# 🌪️ Enhanced Typhoon Analysis Platform")
+        gr.Markdown("**Notice**: Loading with minimal interface due to data issues.")
+        
+        with gr.Tab("📊 Status"):
+            gr.Markdown("""
+            ## Platform Status
+            
+            The application is running but encountered issues loading the full interface.
+            This could be due to:
+            - Data loading problems
+            - Missing dependencies
+            - Configuration issues
+            
+            ### Available Features:
+            - Basic interface is functional
+            - Error logs are being generated
+            - System is ready for debugging
+            
+            ### Next Steps:
+            1. Check the console logs for detailed error information
+            2. Verify all required data files are accessible
+            3. Ensure all dependencies are properly installed
+            4. Try restarting the application
+            """)
+        
+        with gr.Tab("🔧 Debug"):
+            gr.Markdown("## Debug Information")
+            
+            def get_debug_info():
+                debug_text = f"""
+                Python Environment:
+                - Working Directory: {os.getcwd()}
+                - Data Path: {DATA_PATH}
+                - UMAP Available: {UMAP_AVAILABLE}
+                - CNN Available: {CNN_AVAILABLE}
+                
+                Data Status:
+                - ONI Data: {'Loaded' if oni_data is not None else 'Failed'}
+                - Typhoon Data: {'Loaded' if typhoon_data is not None else 'Failed'}
+                - Merged Data: {'Loaded' if merged_data is not None else 'Failed'}
+                
+                File Checks:
+                - ONI Path Exists: {os.path.exists(ONI_DATA_PATH)}
+                - Typhoon Path Exists: {os.path.exists(TYPHOON_DATA_PATH)}
+                """
+                return debug_text
+            
+            debug_btn = gr.Button("Get Debug Info")
+            debug_output = gr.Textbox(label="Debug Information", lines=15)
+            debug_btn.click(fn=get_debug_info, outputs=debug_output)
+    
+    return demo
 
 # -----------------------------
 # Color Test Functions (Optional)