Update app.py

app.py

@@ -631,6 +631,7 @@ def get_available_years():
     years = sorted(years)
     return years
 
+# Function to get available typhoons for a selected year
 # Function to get available typhoons for a selected year
 def get_typhoons_for_year(year):
     if not year or ibtracs is None:
@@ -638,20 +639,77 @@ def get_typhoons_for_year(year):
     
     try:
         year = int(year)
+        if year not in ibtracs.data:
+            return []
+            
         season = ibtracs.get_season(year)
         storm_summary = season.summary()
         
         typhoon_options = []
         for i in range(storm_summary['season_storms']):
-            storm_id = storm_summary['id'][i]
-            storm_name = storm_summary['name'][i]
-            typhoon_options.append((f"{storm_name} ({storm_id})", storm_id))
+            try:
+                storm_id = storm_summary['id'][i]
+                storm_name = storm_summary['name'][i]
+                # Use storm name as the display name, but return the ID as the value
+                display_name = f"{storm_name} ({storm_id})"
+                typhoon_options.append((display_name, storm_id))
+            except Exception as e:
+                print(f"Error retrieving typhoon info: {e}")
+                continue
         
         return typhoon_options
     except Exception as e:
         print(f"Error getting typhoons for year {year}: {e}")
         return []
 
+# In the Gradio interface for the Typhoon Path Animation tab:
+with gr.Tab("Typhoon Path Animation"):
+    with gr.Row():
+        available_years = [year for year in range(1950, 2025) if year in ibtracs.data.keys()] if ibtracs else []
+        year_dropdown = gr.Dropdown(
+            choices=available_years,
+            value=available_years[-1] if available_years else None,
+            label="Year"
+        )
+        
+        typhoon_dropdown = gr.Dropdown(
+            label="Typhoon",
+            interactive=True
+        )
+        
+        standard_dropdown = gr.Dropdown(
+            choices=["atlantic", "taiwan"],
+            value="atlantic",
+            label="Classification Standard"
+        )
+    
+    # Update typhoon dropdown when year changes
+    def update_typhoon_dropdown(year):
+        if not year:
+            return [], None
+        
+        typhoons = get_typhoons_for_year(year)
+        if not typhoons:
+            return [], None
+        
+        return [{"label": name, "value": id} for name, id in typhoons], typhoons[0][1]
+    
+    year_dropdown.change(
+        update_typhoon_dropdown,
+        inputs=year_dropdown,
+        outputs=[typhoon_dropdown, typhoon_dropdown]
+    )
+    
+    animation_button = gr.Button("Generate Animation")
+    
+    typhoon_animation = gr.Plot(label="Typhoon Path Animation")
+    
+    animation_button.click(
+        create_typhoon_path_animation,
+        inputs=[year_dropdown, typhoon_dropdown, standard_dropdown],
+        outputs=typhoon_animation
+    )
+
 # Create animation for typhoon path
 def create_typhoon_path_animation(year, typhoon_id, standard):
     if not year or not typhoon_id:
@@ -802,6 +860,7 @@ def create_typhoon_path_animation(year, typhoon_id, standard):
         print(f"Error creating typhoon path animation: {e}")
         return None
 
+# Function to analyze typhoon tracks 
 # Function to analyze typhoon tracks 
 def analyze_typhoon_tracks(start_year, start_month, end_year, end_month, enso_selection, typhoon_search=""):
     start_date = datetime(int(start_year), int(start_month), 1)
@@ -820,48 +879,68 @@ def analyze_typhoon_tracks(start_year, start_month, end_year, end_month, enso_se
     enso_value = enso_map[enso_selection]
     
     try:
+        processed_storms = 0
         for year in range(int(start_year), int(end_year) + 1):
             if year not in ibtracs.data.keys():
                 continue
             
             season = ibtracs.get_season(year)
             for storm_id in season.summary()['id']:
-                storm = get_storm_data(storm_id)
-                storm_dates = storm.time
-                
-                if any(start_date <= date <= end_date for date in storm_dates):
-                    storm_date_str = storm_dates[0].strftime('%Y-%b')
-                    if storm_date_str in oni_df.index:
-                        storm_oni = oni_df.loc[storm_date_str]['ONI']
-                        if isinstance(storm_oni, pd.Series):
-                            storm_oni = storm_oni.iloc[0]
+                try:
+                    storm = get_storm_data(storm_id)
+                    storm_dates = storm.time
+                    
+                    if any(start_date <= date <= end_date for date in storm_dates):
+                        storm_date_str = storm_dates[0].strftime('%Y-%b')
+                        storm_oni = None
                         
-                        phase = classify_enso_phases(storm_oni)
+                        # Find the ONI value - handle case where date might not be in index
+                        if storm_date_str in oni_df.index:
+                            storm_oni = oni_df.loc[storm_date_str]['ONI']
+                            if isinstance(storm_oni, pd.Series):
+                                storm_oni = storm_oni.iloc[0]
+                        else:
+                            # Try to find closest date
+                            closest_dates = oni_df.index[oni_df.index.year == storm_dates[0].year]
+                            if len(closest_dates) > 0:
+                                closest_date = min(closest_dates, key=lambda x: abs((x - storm_dates[0].to_pydatetime()).total_seconds()))
+                                storm_oni = oni_df.loc[closest_date]['ONI']
+                                if isinstance(storm_oni, pd.Series):
+                                    storm_oni = storm_oni.iloc[0]
                         
-                        if (enso_value == 'all' or 
-                            (enso_value == 'el_nino' and phase == 'El Nino') or
-                            (enso_value == 'la_nina' and phase == 'La Nina') or
-                            (enso_value == 'neutral' and phase == 'Neutral')):
-                            
-                            color = {'El Nino': 'red', 'La Nina': 'blue', 'Neutral': 'green'}[phase]
-                            
-                            # Highlight searched typhoon
-                            if typhoon_search and typhoon_search.lower() in storm.name.lower():
-                                line_width = 5
-                                line_color = 'yellow'
-                            else:
-                                line_width = 2
-                                line_color = color
+                        if storm_oni is not None:
+                            phase = classify_enso_phases(storm_oni)
                             
-                            fig_tracks.add_trace(go.Scattergeo(
-                                lon=storm.lon,
-                                lat=storm.lat,
-                                mode='lines',
-                                name=storm.name,
-                                text=f'{storm.name} ({year})',
-                                hoverinfo='text',
-                                line=dict(width=line_width, color=line_color)
-                            ))
+                            if (enso_value == 'all' or 
+                                (enso_value == 'el_nino' and phase == 'El Nino') or
+                                (enso_value == 'la_nina' and phase == 'La Nina') or
+                                (enso_value == 'neutral' and phase == 'Neutral')):
+                                
+                                color = {'El Nino': 'red', 'La Nina': 'blue', 'Neutral': 'green'}[phase]
+                                
+                                # Highlight searched typhoon
+                                if typhoon_search and typhoon_search.lower() in storm.name.lower():
+                                    line_width = 5
+                                    line_color = 'yellow'
+                                else:
+                                    line_width = 2
+                                    line_color = color
+                                
+                                fig_tracks.add_trace(go.Scattergeo(
+                                    lon=storm.lon,
+                                    lat=storm.lat,
+                                    mode='lines',
+                                    name=storm.name,
+                                    text=f'{storm.name} ({year})',
+                                    hoverinfo='text',
+                                    line=dict(width=line_width, color=line_color)
+                                ))
+                                processed_storms += 1
+                except Exception as e:
+                    print(f"Error processing storm {storm_id}: {e}")
+                    continue
+        
+        print(f"Processed {processed_storms} storms for track display.")
         
         fig_tracks.update_layout(
             title=f'Typhoon Tracks from {start_year}-{start_month} to {end_year}-{end_month}',
@@ -870,6 +949,8 @@ def analyze_typhoon_tracks(start_year, start_month, end_year, end_month, enso_se
                 showland=True,
                 coastlinecolor='rgb(100, 100, 100)',
                 countrycolor='rgb(204, 204, 204)',
+                showocean=True,
+                oceancolor='rgb(230, 250, 255)',
             )
         )
         
@@ -884,7 +965,7 @@ def analyze_typhoon_tracks(start_year, start_month, end_year, end_month, enso_se
         max_wind = filtered_data['USA_WIND'].max() if not filtered_data.empty else 0
         min_press = filtered_data['USA_PRES'].min() if not filtered_data.empty else 0
         
-        stats_text = f"Maximum Wind Speed: {max_wind:.2f} knots\nMinimum Pressure: {min_press:.2f} hPa"
+        stats_text = f"Maximum Wind Speed: {max_wind:.2f} knots\nMinimum Pressure: {min_press:.2f} hPa\nTotal Storms: {processed_storms}"
         
         # Create wind scatter plot
         wind_oni_scatter = px.scatter(filtered_data, x='ONI', y='USA_WIND', color='Category',