Update app.py

app.py

@@ -45,19 +45,8 @@ logging.basicConfig(
     format='%(asctime)s - %(levelname)s - %(message)s'
 )
 
-parser = argparse.ArgumentParser(description='Typhoon Analysis Dashboard')
-parser.add_argument('--data_path', type=str, default=os.getcwd(), help='Path to the data directory')
-args = parser.parse_args()
-
-# Enhanced data path handling for HuggingFace Spaces
-if 'SPACE_ID' in os.environ:
-    # Running on HuggingFace Spaces
-    DATA_PATH = '/tmp/typhoon_data'
-    os.makedirs(DATA_PATH, exist_ok=True)
-    logging.info(f"Running on HuggingFace Spaces, using data path: {DATA_PATH}")
-else:
-    # Local development
-    DATA_PATH = os.environ.get('DATA_PATH', tempfile.gettempdir())
+# Remove argument parser to simplify startup
+DATA_PATH = '/tmp/typhoon_data' if 'SPACE_ID' in os.environ else tempfile.gettempdir()
 
 # Ensure directory exists and is writable
 try:
@@ -117,23 +106,6 @@ taiwan_standard = {
     'Tropical Depression': {'wind_speed': 0, 'color': 'Gray', 'hex': '#808080'}
 }
 
-# -----------------------------
-# Season and Regions
-# -----------------------------
-season_months = {
-    'all': list(range(1, 13)),
-    'summer': [6, 7, 8],
-    'winter': [12, 1, 2]
-}
-regions = {
-    "Taiwan Land": {"lat_min": 21.8, "lat_max": 25.3, "lon_min": 119.5, "lon_max": 122.1},
-    "Taiwan Sea": {"lat_min": 19, "lat_max": 28, "lon_min": 117, "lon_max": 125},
-    "Japan": {"lat_min": 20, "lat_max": 45, "lon_min": 120, "lon_max": 150},
-    "China": {"lat_min": 18, "lat_max": 53, "lon_min": 73, "lon_max": 135},
-    "Hong Kong": {"lat_min": 21.5, "lat_max": 23, "lon_min": 113, "lon_max": 115},
-    "Philippines": {"lat_min": 5, "lat_max": 21, "lon_min": 115, "lon_max": 130}
-}
-
 # -----------------------------
 # Utility Functions for HF Spaces
 # -----------------------------
@@ -168,6 +140,7 @@ def safe_file_write(file_path, data_frame, backup_dir=None):
     except Exception as e:
         logging.error(f"Error saving file {file_path}: {e}")
         # Clean up temp file if it exists
+        temp_path = file_path + '.tmp'
         if os.path.exists(temp_path):
             try:
                 os.remove(temp_path)
@@ -379,9 +352,9 @@ def load_ibtracs_csv_directly(basin='WP'):
             logging.error(f"Missing critical columns. Available: {list(df.columns)}")
             return None
         
-        # Clean and standardize the data
+        # Clean and standardize the data with format specification
         if 'ISO_TIME' in df.columns:
-            df['ISO_TIME'] = pd.to_datetime(df['ISO_TIME'], errors='coerce')
+            df['ISO_TIME'] = pd.to_datetime(df['ISO_TIME'], format='%Y-%m-%d %H:%M:%S', errors='coerce')
         
         # Clean numeric columns
         numeric_columns = ['LAT', 'LON', 'WMO_WIND', 'WMO_PRES', 'USA_WIND', 'USA_PRES']
@@ -720,101 +693,6 @@ def perform_longitude_regression(start_year, start_month, end_year, end_month):
 # Visualization Functions
 # -----------------------------
 
-def generate_typhoon_tracks(filtered_data, typhoon_search):
-    """Generate typhoon tracks visualization"""
-    fig = go.Figure()
-    for sid in filtered_data['SID'].unique():
-        storm_data = filtered_data[filtered_data['SID'] == sid]
-        phase = storm_data['ENSO_Phase'].iloc[0]
-        color = {'El Nino':'red','La Nina':'blue','Neutral':'green'}.get(phase, 'black')
-        fig.add_trace(go.Scattergeo(
-            lon=storm_data['LON'], lat=storm_data['LAT'], mode='lines',
-            name=storm_data['NAME'].iloc[0], line=dict(width=2, color=color)
-        ))
-    if typhoon_search:
-        mask = filtered_data['NAME'].str.contains(typhoon_search, case=False, na=False)
-        if mask.any():
-            storm_data = filtered_data[mask]
-            fig.add_trace(go.Scattergeo(
-                lon=storm_data['LON'], lat=storm_data['LAT'], mode='lines',
-                name=f'Matched: {typhoon_search}', line=dict(width=5, color='yellow')
-            ))
-    fig.update_layout(
-        title='Typhoon Tracks',
-        geo=dict(projection_type='natural earth', showland=True),
-        height=700
-    )
-    return fig
-
-def generate_wind_oni_scatter(filtered_data, typhoon_search):
-    """Generate wind vs ONI scatter plot"""
-    fig = px.scatter(filtered_data, x='ONI', y='USA_WIND', color='Category',
-                     hover_data=['NAME','Year','Category'],
-                     title='Wind Speed vs ONI',
-                     labels={'ONI':'ONI Value','USA_WIND':'Max Wind Speed (knots)'},
-                     color_discrete_map=color_map)
-    if typhoon_search:
-        mask = filtered_data['NAME'].str.contains(typhoon_search, case=False, na=False)
-        if mask.any():
-            fig.add_trace(go.Scatter(
-                x=filtered_data.loc[mask,'ONI'], y=filtered_data.loc[mask,'USA_WIND'],
-                mode='markers', marker=dict(size=10, color='red', symbol='star'),
-                name=f'Matched: {typhoon_search}',
-                text=filtered_data.loc[mask,'NAME']+' ('+filtered_data.loc[mask,'Year'].astype(str)+')'
-            ))
-    return fig
-
-def generate_pressure_oni_scatter(filtered_data, typhoon_search):
-    """Generate pressure vs ONI scatter plot"""
-    fig = px.scatter(filtered_data, x='ONI', y='USA_PRES', color='Category',
-                     hover_data=['NAME','Year','Category'],
-                     title='Pressure vs ONI',
-                     labels={'ONI':'ONI Value','USA_PRES':'Min Pressure (hPa)'},
-                     color_discrete_map=color_map)
-    if typhoon_search:
-        mask = filtered_data['NAME'].str.contains(typhoon_search, case=False, na=False)
-        if mask.any():
-            fig.add_trace(go.Scatter(
-                x=filtered_data.loc[mask,'ONI'], y=filtered_data.loc[mask,'USA_PRES'],
-                mode='markers', marker=dict(size=10, color='red', symbol='star'),
-                name=f'Matched: {typhoon_search}',
-                text=filtered_data.loc[mask,'NAME']+' ('+filtered_data.loc[mask,'Year'].astype(str)+')'
-            ))
-    return fig
-
-def generate_regression_analysis(filtered_data):
-    """Generate regression analysis plot"""
-    fig = px.scatter(filtered_data, x='LON', y='ONI', hover_data=['NAME'],
-                     title='Typhoon Generation Longitude vs ONI (All Years)')
-    if len(filtered_data) > 1:
-        X = np.array(filtered_data['LON']).reshape(-1,1)
-        y = filtered_data['ONI']
-        try:
-            model = sm.OLS(y, sm.add_constant(X)).fit()
-            y_pred = model.predict(sm.add_constant(X))
-            fig.add_trace(go.Scatter(x=filtered_data['LON'], y=y_pred, mode='lines', name='Regression Line'))
-            slope = model.params[1]
-            slopes_text = f"All Years Slope: {slope:.4f}"
-        except Exception as e:
-            slopes_text = f"Regression Error: {e}"
-    else:
-        slopes_text = "Insufficient data for regression"
-    return fig, slopes_text
-
-def generate_main_analysis(start_year, start_month, end_year, end_month, enso_phase, typhoon_search):
-    """Generate main analysis plots"""
-    start_date = datetime(start_year, start_month, 1)
-    end_date = datetime(end_year, end_month, 28)
-    filtered_data = merged_data[(merged_data['ISO_TIME']>=start_date) & (merged_data['ISO_TIME']<=end_date)].copy()
-    filtered_data['ENSO_Phase'] = filtered_data['ONI'].apply(classify_enso_phases)
-    if enso_phase != 'all':
-        filtered_data = filtered_data[filtered_data['ENSO_Phase'] == enso_phase.capitalize()]
-    tracks_fig = generate_typhoon_tracks(filtered_data, typhoon_search)
-    wind_scatter = generate_wind_oni_scatter(filtered_data, typhoon_search)
-    pressure_scatter = generate_pressure_oni_scatter(filtered_data, typhoon_search)
-    regression_fig, slopes_text = generate_regression_analysis(filtered_data)
-    return tracks_fig, wind_scatter, pressure_scatter, regression_fig, slopes_text
-
 def get_full_tracks(start_year, start_month, end_year, end_month, enso_phase, typhoon_search):
     """Get full typhoon tracks"""
     start_date = datetime(start_year, start_month, 1)
@@ -876,21 +754,88 @@ def get_full_tracks(start_year, start_month, end_year, end_month, enso_phase, ty
 
 def get_wind_analysis(start_year, start_month, end_year, end_month, enso_phase, typhoon_search):
     """Get wind analysis"""
-    results = generate_main_analysis(start_year, start_month, end_year, end_month, enso_phase, typhoon_search)
+    start_date = datetime(start_year, start_month, 1)
+    end_date = datetime(end_year, end_month, 28)
+    filtered_data = merged_data[(merged_data['ISO_TIME']>=start_date) & (merged_data['ISO_TIME']<=end_date)].copy()
+    filtered_data['ENSO_Phase'] = filtered_data['ONI'].apply(classify_enso_phases)
+    if enso_phase != 'all':
+        filtered_data = filtered_data[filtered_data['ENSO_Phase'] == enso_phase.capitalize()]
+    
+    fig = px.scatter(filtered_data, x='ONI', y='USA_WIND', color='Category',
+                     hover_data=['NAME','Year','Category'],
+                     title='Wind Speed vs ONI',
+                     labels={'ONI':'ONI Value','USA_WIND':'Max Wind Speed (knots)'},
+                     color_discrete_map=color_map)
+    
+    if typhoon_search:
+        mask = filtered_data['NAME'].str.contains(typhoon_search, case=False, na=False)
+        if mask.any():
+            fig.add_trace(go.Scatter(
+                x=filtered_data.loc[mask,'ONI'], y=filtered_data.loc[mask,'USA_WIND'],
+                mode='markers', marker=dict(size=10, color='red', symbol='star'),
+                name=f'Matched: {typhoon_search}',
+                text=filtered_data.loc[mask,'NAME']+' ('+filtered_data.loc[mask,'Year'].astype(str)+')'
+            ))
+    
     regression = perform_wind_regression(start_year, start_month, end_year, end_month)
-    return results[1], regression
+    return fig, regression
 
 def get_pressure_analysis(start_year, start_month, end_year, end_month, enso_phase, typhoon_search):
     """Get pressure analysis"""
-    results = generate_main_analysis(start_year, start_month, end_year, end_month, enso_phase, typhoon_search)
+    start_date = datetime(start_year, start_month, 1)
+    end_date = datetime(end_year, end_month, 28)
+    filtered_data = merged_data[(merged_data['ISO_TIME']>=start_date) & (merged_data['ISO_TIME']<=end_date)].copy()
+    filtered_data['ENSO_Phase'] = filtered_data['ONI'].apply(classify_enso_phases)
+    if enso_phase != 'all':
+        filtered_data = filtered_data[filtered_data['ENSO_Phase'] == enso_phase.capitalize()]
+    
+    fig = px.scatter(filtered_data, x='ONI', y='USA_PRES', color='Category',
+                     hover_data=['NAME','Year','Category'],
+                     title='Pressure vs ONI',
+                     labels={'ONI':'ONI Value','USA_PRES':'Min Pressure (hPa)'},
+                     color_discrete_map=color_map)
+    
+    if typhoon_search:
+        mask = filtered_data['NAME'].str.contains(typhoon_search, case=False, na=False)
+        if mask.any():
+            fig.add_trace(go.Scatter(
+                x=filtered_data.loc[mask,'ONI'], y=filtered_data.loc[mask,'USA_PRES'],
+                mode='markers', marker=dict(size=10, color='red', symbol='star'),
+                name=f'Matched: {typhoon_search}',
+                text=filtered_data.loc[mask,'NAME']+' ('+filtered_data.loc[mask,'Year'].astype(str)+')'
+            ))
+    
     regression = perform_pressure_regression(start_year, start_month, end_year, end_month)
-    return results[2], regression
+    return fig, regression
 
 def get_longitude_analysis(start_year, start_month, end_year, end_month, enso_phase, typhoon_search):
     """Get longitude analysis"""
-    results = generate_main_analysis(start_year, start_month, end_year, end_month, enso_phase, typhoon_search)
+    start_date = datetime(start_year, start_month, 1)
+    end_date = datetime(end_year, end_month, 28)
+    filtered_data = merged_data[(merged_data['ISO_TIME']>=start_date) & (merged_data['ISO_TIME']<=end_date)].copy()
+    filtered_data['ENSO_Phase'] = filtered_data['ONI'].apply(classify_enso_phases)
+    if enso_phase != 'all':
+        filtered_data = filtered_data[filtered_data['ENSO_Phase'] == enso_phase.capitalize()]
+    
+    fig = px.scatter(filtered_data, x='LON', y='ONI', hover_data=['NAME'],
+                     title='Typhoon Generation Longitude vs ONI (All Years)')
+    
+    if len(filtered_data) > 1:
+        X = np.array(filtered_data['LON']).reshape(-1,1)
+        y = filtered_data['ONI']
+        try:
+            model = sm.OLS(y, sm.add_constant(X)).fit()
+            y_pred = model.predict(sm.add_constant(X))
+            fig.add_trace(go.Scatter(x=filtered_data['LON'], y=y_pred, mode='lines', name='Regression Line'))
+            slope = model.params[1]
+            slopes_text = f"All Years Slope: {slope:.4f}"
+        except Exception as e:
+            slopes_text = f"Regression Error: {e}"
+    else:
+        slopes_text = "Insufficient data for regression"
+    
     regression = perform_longitude_regression(start_year, start_month, end_year, end_month)
-    return results[3], results[4], regression
+    return fig, slopes_text, regression
 
 def categorize_typhoon_by_standard(wind_speed, standard='atlantic'):
     """Categorize typhoon by standard"""
@@ -921,246 +866,6 @@ def categorize_typhoon_by_standard(wind_speed, standard='atlantic'):
             return 'Tropical Storm', atlantic_standard['Tropical Storm']['hex']
         return 'Tropical Depression', atlantic_standard['Tropical Depression']['hex']
 
-# -----------------------------
-# TSNE Cluster Function
-# -----------------------------
-
-def update_route_clusters(start_year, start_month, end_year, end_month, enso_value, season):
-    """Updated TSNE cluster function with mean curves"""
-    try:
-        # Merge raw typhoon data with ONI
-        raw_data = typhoon_data.copy()
-        if 'ISO_TIME' not in raw_data.columns:
-            logging.error("ISO_TIME column not found in typhoon data")
-            return go.Figure(), go.Figure(), make_subplots(rows=2, cols=1), "Error: ISO_TIME column missing"
-        
-        raw_data['Year'] = raw_data['ISO_TIME'].dt.year
-        raw_data['Month'] = raw_data['ISO_TIME'].dt.strftime('%m')
-        merged_raw = pd.merge(raw_data, process_oni_data(oni_data), on=['Year','Month'], how='left')
-        
-        # Filter by date
-        start_date = datetime(start_year, start_month, 1)
-        end_date = datetime(end_year, end_month, 28)
-        merged_raw = merged_raw[(merged_raw['ISO_TIME'] >= start_date) & (merged_raw['ISO_TIME'] <= end_date)]
-        logging.info(f"Total points after date filtering: {merged_raw.shape[0]}")
-        
-        # Filter by ENSO phase if specified
-        merged_raw['ENSO_Phase'] = merged_raw['ONI'].apply(classify_enso_phases)
-        if enso_value != 'all':
-            merged_raw = merged_raw[merged_raw['ENSO_Phase'] == enso_value.capitalize()]
-        logging.info(f"Total points after ENSO filtering: {merged_raw.shape[0]}")
-        
-        # Regional filtering for Western Pacific
-        wp_data = merged_raw[(merged_raw['LON'] >= 100) & (merged_raw['LON'] <= 180) &
-                             (merged_raw['LAT'] >= 0) & (merged_raw['LAT'] <= 40)]
-        logging.info(f"Total points after WP regional filtering: {wp_data.shape[0]}")
-        if wp_data.empty:
-            logging.info("WP regional filter returned no data; using all filtered data.")
-            wp_data = merged_raw
-        
-        # Group by storm ID
-        all_storms_data = []
-        for sid, group in wp_data.groupby('SID'):
-            group = group.sort_values('ISO_TIME')
-            times = pd.to_datetime(group['ISO_TIME']).values
-            lats = group['LAT'].astype(float).values
-            lons = group['LON'].astype(float).values
-            if len(lons) < 2:
-                continue
-            # Extract wind and pressure curves
-            wind = group['USA_WIND'].astype(float).values if 'USA_WIND' in group.columns else None
-            pres = group['USA_PRES'].astype(float).values if 'USA_PRES' in group.columns else None
-            all_storms_data.append((sid, lons, lats, times, wind, pres))
-        
-        logging.info(f"Storms available for TSNE after grouping: {len(all_storms_data)}")
-        if not all_storms_data:
-            return go.Figure(), go.Figure(), make_subplots(rows=2, cols=1), "No valid storms for clustering."
-        
-        # Interpolate each storm's route to a common length
-        max_length = min(50, max(len(item[1]) for item in all_storms_data))  # Cap at 50 points
-        route_vectors = []
-        wind_curves = []
-        pres_curves = []
-        storm_ids = []
-        
-        for sid, lons, lats, times, wind, pres in all_storms_data:
-            t = np.linspace(0, 1, len(lons))
-            t_new = np.linspace(0, 1, max_length)
-            try:
-                lon_interp = interp1d(t, lons, kind='linear', fill_value='extrapolate')(t_new)
-                lat_interp = interp1d(t, lats, kind='linear', fill_value='extrapolate')(t_new)
-            except Exception as ex:
-                logging.error(f"Interpolation error for storm {sid}: {ex}")
-                continue
-            
-            route_vector = np.column_stack((lon_interp, lat_interp)).flatten()
-            if np.isnan(route_vector).any():
-                continue
-            
-            route_vectors.append(route_vector)
-            storm_ids.append(sid)
-            
-            # Interpolate wind and pressure
-            if wind is not None and len(wind) >= 2:
-                try:
-                    wind_interp = interp1d(t, wind, kind='linear', fill_value='extrapolate')(t_new)
-                except Exception as ex:
-                    logging.error(f"Wind interpolation error for storm {sid}: {ex}")
-                    wind_interp = np.full(max_length, np.nan)
-            else:
-                wind_interp = np.full(max_length, np.nan)
-            
-            if pres is not None and len(pres) >= 2:
-                try:
-                    pres_interp = interp1d(t, pres, kind='linear', fill_value='extrapolate')(t_new)
-                except Exception as ex:
-                    logging.error(f"Pressure interpolation error for storm {sid}: {ex}")
-                    pres_interp = np.full(max_length, np.nan)
-            else:
-                pres_interp = np.full(max_length, np.nan)
-            
-            wind_curves.append(wind_interp)
-            pres_curves.append(pres_interp)
-        
-        logging.info(f"Storms with valid route vectors: {len(route_vectors)}")
-        if len(route_vectors) == 0:
-            return go.Figure(), go.Figure(), make_subplots(rows=2, cols=1), "No valid storms after interpolation."
-        
-        route_vectors = np.array(route_vectors)
-        wind_curves = np.array(wind_curves)
-        pres_curves = np.array(pres_curves)
-        
-        # Run TSNE on route vectors
-        if len(route_vectors) < 5:
-            return go.Figure(), go.Figure(), make_subplots(rows=2, cols=1), "Need at least 5 storms for clustering."
-        
-        tsne = TSNE(n_components=2, random_state=42, verbose=1, perplexity=min(30, len(route_vectors)-1))
-        tsne_results = tsne.fit_transform(route_vectors)
-        
-        # Dynamic DBSCAN
-        selected_labels = None
-        selected_eps = None
-        for eps in np.linspace(1.0, 10.0, 91):
-            dbscan = DBSCAN(eps=eps, min_samples=max(2, len(route_vectors)//10))
-            labels = dbscan.fit_predict(tsne_results)
-            clusters = set(labels) - {-1}
-            if 2 <= len(clusters) <= min(10, len(route_vectors)//2):
-                selected_labels = labels
-                selected_eps = eps
-                break
-        
-        if selected_labels is None:
-            selected_eps = 5.0
-            dbscan = DBSCAN(eps=selected_eps, min_samples=max(2, len(route_vectors)//10))
-            selected_labels = dbscan.fit_predict(tsne_results)
-        
-        logging.info(f"Selected DBSCAN eps: {selected_eps:.2f} yielding {len(set(selected_labels)-{-1})} clusters.")
-        
-        # TSNE scatter plot
-        fig_tsne = go.Figure()
-        colors = px.colors.qualitative.Set3
-        unique_labels = sorted(set(selected_labels) - {-1})
-        
-        for i, label in enumerate(unique_labels):
-            indices = np.where(selected_labels == label)[0]
-            fig_tsne.add_trace(go.Scatter(
-                x=tsne_results[indices, 0],
-                y=tsne_results[indices, 1],
-                mode='markers',
-                marker=dict(color=colors[i % len(colors)]),
-                name=f"Cluster {label}"
-            ))
-        
-        noise_indices = np.where(selected_labels == -1)[0]
-        if len(noise_indices) > 0:
-            fig_tsne.add_trace(go.Scatter(
-                x=tsne_results[noise_indices, 0],
-                y=tsne_results[noise_indices, 1],
-                mode='markers',
-                marker=dict(color='grey'),
-                name='Noise'
-            ))
-        
-        fig_tsne.update_layout(
-            title="t-SNE of Storm Routes",
-            xaxis_title="t-SNE Dim 1",
-            yaxis_title="t-SNE Dim 2"
-        )
-        
-        # Compute mean routes and curves for each cluster
-        fig_routes = go.Figure()
-        cluster_stats = []
-        
-        for i, label in enumerate(unique_labels):
-            indices = np.where(selected_labels == label)[0]
-            cluster_ids = [storm_ids[j] for j in indices]
-            cluster_vectors = route_vectors[indices, :]
-            mean_vector = np.mean(cluster_vectors, axis=0)
-            mean_route = mean_vector.reshape((max_length, 2))
-            mean_lon = mean_route[:, 0]
-            mean_lat = mean_route[:, 1]
-            
-            fig_routes.add_trace(go.Scattergeo(
-                lon=mean_lon,
-                lat=mean_lat,
-                mode='lines',
-                line=dict(width=4, color=colors[i % len(colors)]),
-                name=f"Cluster {label} Mean Route"
-            ))
-            
-            # Compute mean curves
-            cluster_winds = wind_curves[indices, :]
-            cluster_pres = pres_curves[indices, :]
-            mean_wind_curve = np.nanmean(cluster_winds, axis=0)
-            mean_pres_curve = np.nanmean(cluster_pres, axis=0)
-            cluster_stats.append((label, mean_wind_curve, mean_pres_curve))
-        
-        fig_routes.update_layout(
-            title="Cluster Mean Routes",
-            geo=dict(projection_type='natural earth', showland=True),
-            height=600
-        )
-        
-        # Create cluster stats plot
-        x_axis = np.linspace(0, 1, max_length)
-        fig_stats = make_subplots(rows=2, cols=1, shared_xaxes=True,
-                                  subplot_titles=("Mean Wind Speed (knots)", "Mean MSLP (hPa)"))
-        
-        for i, (label, wind_curve, pres_curve) in enumerate(cluster_stats):
-            fig_stats.add_trace(go.Scatter(
-                x=x_axis,
-                y=wind_curve,
-                mode='lines',
-                line=dict(width=2, color=colors[i % len(colors)]),
-                name=f"Cluster {label} Mean Wind",
-                showlegend=True
-            ), row=1, col=1)
-            
-            fig_stats.add_trace(go.Scatter(
-                x=x_axis,
-                y=pres_curve,
-                mode='lines',
-                line=dict(width=2, color=colors[i % len(colors)]),
-                name=f"Cluster {label} Mean MSLP",
-                showlegend=False
-            ), row=2, col=1)
-        
-        fig_stats.update_layout(
-            title="Cluster Mean Curves",
-            xaxis_title="Normalized Route Index",
-            yaxis_title="Mean Wind Speed (knots)",
-            xaxis2_title="Normalized Route Index",
-            yaxis2_title="Mean MSLP (hPa)",
-            height=600
-        )
-        
-        info = f"TSNE clustering complete. Selected eps: {selected_eps:.2f}. Clusters: {len(unique_labels)}. Total storms: {len(route_vectors)}."
-        return fig_tsne, fig_routes, fig_stats, info
-        
-    except Exception as e:
-        logging.error(f"Error in TSNE clustering: {e}")
-        return go.Figure(), go.Figure(), make_subplots(rows=2, cols=1), f"Error in TSNE clustering: {e}"
-
 # -----------------------------
 # Animation Functions
 # -----------------------------
@@ -1259,7 +964,7 @@ def simplified_track_video(year, basin, typhoon, standard):
     return generate_track_video_from_csv(year, storm_id, standard)
 
 # -----------------------------
-# FIXED: Update Typhoon Options Function 
+# Update Typhoon Options Function 
 # -----------------------------
 
 def update_typhoon_options_fixed(year, basin):
@@ -1313,149 +1018,190 @@ def update_typhoon_options_fixed(year, basin):
         return gr.update(choices=[], value=None)
 
 # -----------------------------
-# Load & Process Data (using fixed functions)
+# Load & Process Data
 # -----------------------------
 
-logging.info("Starting data loading process...")
-update_oni_data()
-oni_data, typhoon_data = load_data_fixed(ONI_DATA_PATH, TYPHOON_DATA_PATH)
-oni_long = process_oni_data(oni_data)
-typhoon_max = process_typhoon_data(typhoon_data)
-merged_data = merge_data(oni_long, typhoon_max)
-logging.info("Data loading complete.")
+# Global variables initialization
+oni_data = None
+typhoon_data = None
+merged_data = None
+
+def initialize_data():
+    """Initialize all data safely"""
+    global oni_data, typhoon_data, merged_data
+    try:
+        logging.info("Starting data loading process...")
+        update_oni_data()
+        oni_data, typhoon_data = load_data_fixed(ONI_DATA_PATH, TYPHOON_DATA_PATH)
+        
+        if oni_data is not None and typhoon_data is not None:
+            oni_long = process_oni_data(oni_data)
+            typhoon_max = process_typhoon_data(typhoon_data)
+            merged_data = merge_data(oni_long, typhoon_max)
+            logging.info("Data loading complete.")
+        else:
+            logging.error("Failed to load required data")
+            # Create minimal fallback data
+            oni_data = pd.DataFrame({'Year': [2000], 'Jan': [0], 'Feb': [0], 'Mar': [0], 'Apr': [0], 
+                                   'May': [0], 'Jun': [0], 'Jul': [0], 'Aug': [0], 'Sep': [0], 
+                                   'Oct': [0], 'Nov': [0], 'Dec': [0]})
+            typhoon_data = create_fallback_typhoon_data()
+            oni_long = process_oni_data(oni_data)
+            typhoon_max = process_typhoon_data(typhoon_data)
+            merged_data = merge_data(oni_long, typhoon_max)
+    except Exception as e:
+        logging.error(f"Error during data initialization: {e}")
+        # Create minimal fallback data
+        oni_data = pd.DataFrame({'Year': [2000], 'Jan': [0], 'Feb': [0], 'Mar': [0], 'Apr': [0], 
+                               'May': [0], 'Jun': [0], 'Jul': [0], 'Aug': [0], 'Sep': [0], 
+                               'Oct': [0], 'Nov': [0], 'Dec': [0]})
+        typhoon_data = create_fallback_typhoon_data()
+        oni_long = process_oni_data(oni_data)
+        typhoon_max = process_typhoon_data(typhoon_data)
+        merged_data = merge_data(oni_long, typhoon_max)
+
+# Initialize data
+initialize_data()
 
 # -----------------------------
-# FIXED Gradio Interface
+# Simplified Gradio Interface
 # -----------------------------
 
-# Fixed Gradio interface creation
-with gr.Blocks(title="Typhoon Analysis Dashboard") as demo:
-    gr.Markdown("# Typhoon Analysis Dashboard")
-    
-    with gr.Tab("Overview"):
-        gr.Markdown("""
-        ## Welcome to the Typhoon Analysis Dashboard
+def create_interface():
+    """Create the Gradio interface with error handling"""
+    try:
+        # Initialize components with safe defaults
+        with gr.Blocks() as demo:
+            gr.Markdown("# Typhoon Analysis Dashboard")
+            
+            with gr.Tab("Overview"):
+                gr.Markdown(f"""
+                ## Welcome to the Typhoon Analysis Dashboard
 
-        This dashboard allows you to analyze typhoon data in relation to ENSO phases.
+                This dashboard allows you to analyze typhoon data in relation to ENSO phases.
 
-        ### Features:
-        - **Track Visualization**: View typhoon tracks by time period and ENSO phase.
-        - **Wind Analysis**: Examine wind speed vs ONI relationships.
-        - **Pressure Analysis**: Analyze pressure vs ONI relationships.
-        - **Longitude Analysis**: Study typhoon generation longitude vs ONI.
-        - **Path Animation**: View animated storm tracks on a world map.
-        - **TSNE Cluster**: Perform t-SNE clustering on storm routes.
-        
-        ### Data Status:
-        - **ONI Data**: %d years loaded
-        - **Typhoon Data**: %d records loaded
-        - **Merged Data**: %d typhoons with ONI values
-        """ % (len(oni_data), len(typhoon_data), len(merged_data)))
+                ### Features:
+                - **Track Visualization**: View typhoon tracks by time period and ENSO phase.
+                - **Wind Analysis**: Examine wind speed vs ONI relationships.
+                - **Pressure Analysis**: Analyze pressure vs ONI relationships.
+                - **Longitude Analysis**: Study typhoon generation longitude vs ONI.
+                - **Path Animation**: View animated storm tracks on a world map.
+                
+                ### Data Status:
+                - **ONI Data**: {len(oni_data)} years loaded
+                - **Typhoon Data**: {len(typhoon_data)} records loaded
+                - **Merged Data**: {len(merged_data)} typhoons with ONI values
+                """)
 
-    with gr.Tab("Track Visualization"):
-        with gr.Row():
-            start_year = gr.Number(label="Start Year", value=2000, minimum=1900, maximum=2024, step=1)
-            start_month = gr.Dropdown(label="Start Month", choices=list(range(1, 13)), value=1)
-            end_year = gr.Number(label="End Year", value=2024, minimum=1900, maximum=2024, step=1)
-            end_month = gr.Dropdown(label="End Month", choices=list(range(1, 13)), value=6)
-            enso_phase = gr.Dropdown(label="ENSO Phase", choices=['all', 'El Nino', 'La Nina', 'Neutral'], value='all')
-            typhoon_search = gr.Textbox(label="Typhoon Search")
-        analyze_btn = gr.Button("Generate Tracks")
-        tracks_plot = gr.Plot(label="Typhoon Tracks")
-        typhoon_count = gr.Textbox(label="Number of Typhoons Displayed")
-        analyze_btn.click(fn=get_full_tracks,
-                          inputs=[start_year, start_month, end_year, end_month, enso_phase, typhoon_search],
-                          outputs=[tracks_plot, typhoon_count])
-    
-    with gr.Tab("Wind Analysis"):
-        with gr.Row():
-            wind_start_year = gr.Number(label="Start Year", value=2000, minimum=1900, maximum=2024, step=1)
-            wind_start_month = gr.Dropdown(label="Start Month", choices=list(range(1, 13)), value=1)
-            wind_end_year = gr.Number(label="End Year", value=2024, minimum=1900, maximum=2024, step=1)
-            wind_end_month = gr.Dropdown(label="End Month", choices=list(range(1, 13)), value=6)
-            wind_enso_phase = gr.Dropdown(label="ENSO Phase", choices=['all', 'El Nino', 'La Nina', 'Neutral'], value='all')
-            wind_typhoon_search = gr.Textbox(label="Typhoon Search")
-        wind_analyze_btn = gr.Button("Generate Wind Analysis")
-        wind_scatter = gr.Plot(label="Wind Speed vs ONI")
-        wind_regression_results = gr.Textbox(label="Wind Regression Results")
-        wind_analyze_btn.click(fn=get_wind_analysis,
-                               inputs=[wind_start_year, wind_start_month, wind_end_year, wind_end_month, wind_enso_phase, wind_typhoon_search],
-                               outputs=[wind_scatter, wind_regression_results])
-    
-    with gr.Tab("Pressure Analysis"):
-        with gr.Row():
-            pressure_start_year = gr.Number(label="Start Year", value=2000, minimum=1900, maximum=2024, step=1)
-            pressure_start_month = gr.Dropdown(label="Start Month", choices=list(range(1, 13)), value=1)
-            pressure_end_year = gr.Number(label="End Year", value=2024, minimum=1900, maximum=2024, step=1)
-            pressure_end_month = gr.Dropdown(label="End Month", choices=list(range(1, 13)), value=6)
-            pressure_enso_phase = gr.Dropdown(label="ENSO Phase", choices=['all', 'El Nino', 'La Nina', 'Neutral'], value='all')
-            pressure_typhoon_search = gr.Textbox(label="Typhoon Search")
-        pressure_analyze_btn = gr.Button("Generate Pressure Analysis")
-        pressure_scatter = gr.Plot(label="Pressure vs ONI")
-        pressure_regression_results = gr.Textbox(label="Pressure Regression Results")
-        pressure_analyze_btn.click(fn=get_pressure_analysis,
-                                   inputs=[pressure_start_year, pressure_start_month, pressure_end_year, pressure_end_month, pressure_enso_phase, pressure_typhoon_search],
-                                   outputs=[pressure_scatter, pressure_regression_results])
-    
-    with gr.Tab("Longitude Analysis"):
-        with gr.Row():
-            lon_start_year = gr.Number(label="Start Year", value=2000, minimum=1900, maximum=2024, step=1)
-            lon_start_month = gr.Dropdown(label="Start Month", choices=list(range(1, 13)), value=1)
-            lon_end_year = gr.Number(label="End Year", value=2000, minimum=1900, maximum=2024, step=1)
-            lon_end_month = gr.Dropdown(label="End Month", choices=list(range(1, 13)), value=6)
-            lon_enso_phase = gr.Dropdown(label="ENSO Phase", choices=['all', 'El Nino', 'La Nina', 'Neutral'], value='all')
-            lon_typhoon_search = gr.Textbox(label="Typhoon Search (Optional)")
-        lon_analyze_btn = gr.Button("Generate Longitude Analysis")
-        regression_plot = gr.Plot(label="Longitude vs ONI")
-        slopes_text = gr.Textbox(label="Regression Slopes")
-        lon_regression_results = gr.Textbox(label="Longitude Regression Results")
-        lon_analyze_btn.click(fn=get_longitude_analysis,
-                              inputs=[lon_start_year, lon_start_month, lon_end_year, lon_end_month, lon_enso_phase, lon_typhoon_search],
-                              outputs=[regression_plot, slopes_text, lon_regression_results])
-    
-    with gr.Tab("Tropical Cyclone Path Animation"):
-        with gr.Row():
-            year_dropdown = gr.Dropdown(label="Year", choices=[str(y) for y in range(1950, 2025)], value="2000")
-            basin_constant = gr.Textbox(value="All Basins", visible=False)
-        with gr.Row():
-            typhoon_dropdown = gr.Dropdown(label="Tropical Cyclone")
-            standard_dropdown = gr.Dropdown(label="Classification Standard", choices=['atlantic', 'taiwan'], value='atlantic')
-        animate_btn = gr.Button("Generate Animation")
-        # Fixed Video component - removed format and elem_id parameters
-        path_video = gr.Video(label="Tropical Cyclone Path Animation", interactive=False)
-        animation_info = gr.Markdown("""
-        ### Animation Instructions
-        1. Select a year.
-        2. Choose a tropical cyclone from the populated list.
-        3. Select a classification standard (Atlantic or Taiwan).
-        4. Click "Generate Animation".
-        5. The animation displays the storm track on a world map with dynamic sidebar information.
-        """)
-        # Update typhoon dropdown using fixed function
-        year_dropdown.change(fn=update_typhoon_options_fixed, 
-                            inputs=[year_dropdown, basin_constant], 
-                            outputs=typhoon_dropdown)
-        animate_btn.click(fn=simplified_track_video,
-                          inputs=[year_dropdown, basin_constant, typhoon_dropdown, standard_dropdown],
-                          outputs=path_video)
-    
-    with gr.Tab("TSNE Cluster"):
-        with gr.Row():
-            tsne_start_year = gr.Number(label="Start Year", value=2000, minimum=1900, maximum=2024, step=1)
-            tsne_start_month = gr.Dropdown(label="Start Month", choices=list(range(1, 13)), value=1)
-            tsne_end_year = gr.Number(label="End Year", value=2024, minimum=1900, maximum=2024, step=1)
-            tsne_end_month = gr.Dropdown(label="End Month", choices=list(range(1, 13)), value=12)
-            tsne_enso_phase = gr.Dropdown(label="ENSO Phase", choices=['all', 'El Nino', 'La Nina', 'Neutral'], value='all')
-            tsne_season = gr.Dropdown(label="Season", choices=['all', 'summer', 'winter'], value='all')
-        tsne_analyze_btn = gr.Button("Analyze")
-        tsne_plot = gr.Plot(label="t-SNE Clusters")
-        routes_plot = gr.Plot(label="Typhoon Routes with Mean Routes")
-        stats_plot = gr.Plot(label="Cluster Statistics")
-        cluster_info = gr.Textbox(label="Cluster Information", lines=10)
-        tsne_analyze_btn.click(fn=update_route_clusters,
-                               inputs=[tsne_start_year, tsne_start_month, tsne_end_year, tsne_end_month, tsne_enso_phase, tsne_season],
-                               outputs=[tsne_plot, routes_plot, stats_plot, cluster_info])
+            with gr.Tab("Track Visualization"):
+                with gr.Row():
+                    start_year = gr.Number(label="Start Year", value=2000)
+                    start_month = gr.Dropdown(label="Start Month", choices=list(range(1, 13)), value=1)
+                    end_year = gr.Number(label="End Year", value=2024)
+                    end_month = gr.Dropdown(label="End Month", choices=list(range(1, 13)), value=6)
+                    enso_phase = gr.Dropdown(label="ENSO Phase", choices=['all', 'El Nino', 'La Nina', 'Neutral'], value='all')
+                    typhoon_search = gr.Textbox(label="Typhoon Search")
+                analyze_btn = gr.Button("Generate Tracks")
+                tracks_plot = gr.Plot()
+                typhoon_count = gr.Textbox(label="Number of Typhoons Displayed")
+                analyze_btn.click(
+                    fn=get_full_tracks,
+                    inputs=[start_year, start_month, end_year, end_month, enso_phase, typhoon_search],
+                    outputs=[tracks_plot, typhoon_count]
+                )
+            
+            with gr.Tab("Wind Analysis"):
+                with gr.Row():
+                    wind_start_year = gr.Number(label="Start Year", value=2000)
+                    wind_start_month = gr.Dropdown(label="Start Month", choices=list(range(1, 13)), value=1)
+                    wind_end_year = gr.Number(label="End Year", value=2024)
+                    wind_end_month = gr.Dropdown(label="End Month", choices=list(range(1, 13)), value=6)
+                    wind_enso_phase = gr.Dropdown(label="ENSO Phase", choices=['all', 'El Nino', 'La Nina', 'Neutral'], value='all')
+                    wind_typhoon_search = gr.Textbox(label="Typhoon Search")
+                wind_analyze_btn = gr.Button("Generate Wind Analysis")
+                wind_scatter = gr.Plot()
+                wind_regression_results = gr.Textbox(label="Wind Regression Results")
+                wind_analyze_btn.click(
+                    fn=get_wind_analysis,
+                    inputs=[wind_start_year, wind_start_month, wind_end_year, wind_end_month, wind_enso_phase, wind_typhoon_search],
+                    outputs=[wind_scatter, wind_regression_results]
+                )
+            
+            with gr.Tab("Pressure Analysis"):
+                with gr.Row():
+                    pressure_start_year = gr.Number(label="Start Year", value=2000)
+                    pressure_start_month = gr.Dropdown(label="Start Month", choices=list(range(1, 13)), value=1)
+                    pressure_end_year = gr.Number(label="End Year", value=2024)
+                    pressure_end_month = gr.Dropdown(label="End Month", choices=list(range(1, 13)), value=6)
+                    pressure_enso_phase = gr.Dropdown(label="ENSO Phase", choices=['all', 'El Nino', 'La Nina', 'Neutral'], value='all')
+                    pressure_typhoon_search = gr.Textbox(label="Typhoon Search")
+                pressure_analyze_btn = gr.Button("Generate Pressure Analysis")
+                pressure_scatter = gr.Plot()
+                pressure_regression_results = gr.Textbox(label="Pressure Regression Results")
+                pressure_analyze_btn.click(
+                    fn=get_pressure_analysis,
+                    inputs=[pressure_start_year, pressure_start_month, pressure_end_year, pressure_end_month, pressure_enso_phase, pressure_typhoon_search],
+                    outputs=[pressure_scatter, pressure_regression_results]
+                )
+            
+            with gr.Tab("Longitude Analysis"):
+                with gr.Row():
+                    lon_start_year = gr.Number(label="Start Year", value=2000)
+                    lon_start_month = gr.Dropdown(label="Start Month", choices=list(range(1, 13)), value=1)
+                    lon_end_year = gr.Number(label="End Year", value=2000)
+                    lon_end_month = gr.Dropdown(label="End Month", choices=list(range(1, 13)), value=6)
+                    lon_enso_phase = gr.Dropdown(label="ENSO Phase", choices=['all', 'El Nino', 'La Nina', 'Neutral'], value='all')
+                    lon_typhoon_search = gr.Textbox(label="Typhoon Search (Optional)")
+                lon_analyze_btn = gr.Button("Generate Longitude Analysis")
+                regression_plot = gr.Plot()
+                slopes_text = gr.Textbox(label="Regression Slopes")
+                lon_regression_results = gr.Textbox(label="Longitude Regression Results")
+                lon_analyze_btn.click(
+                    fn=get_longitude_analysis,
+                    inputs=[lon_start_year, lon_start_month, lon_end_year, lon_end_month, lon_enso_phase, lon_typhoon_search],
+                    outputs=[regression_plot, slopes_text, lon_regression_results]
+                )
+            
+            with gr.Tab("Tropical Cyclone Path Animation"):
+                with gr.Row():
+                    year_dropdown = gr.Dropdown(label="Year", choices=[str(y) for y in range(1950, 2025)], value="2000")
+                    basin_constant = gr.Textbox(value="All Basins", visible=False)
+                with gr.Row():
+                    typhoon_dropdown = gr.Dropdown(label="Tropical Cyclone")
+                    standard_dropdown = gr.Dropdown(label="Classification Standard", choices=['atlantic', 'taiwan'], value='atlantic')
+                animate_btn = gr.Button("Generate Animation")
+                path_video = gr.Video()
+                animation_info = gr.Markdown("""
+                ### Animation Instructions
+                1. Select a year.
+                2. Choose a tropical cyclone from the populated list.
+                3. Select a classification standard (Atlantic or Taiwan).
+                4. Click "Generate Animation".
+                5. The animation displays the storm track on a world map with dynamic sidebar information.
+                """)
+                # Update typhoon dropdown
+                year_dropdown.change(
+                    fn=update_typhoon_options_fixed,
+                    inputs=[year_dropdown, basin_constant],
+                    outputs=typhoon_dropdown
+                )
+                animate_btn.click(
+                    fn=simplified_track_video,
+                    inputs=[year_dropdown, basin_constant, typhoon_dropdown, standard_dropdown],
+                    outputs=path_video
+                )
+
+        return demo
+    except Exception as e:
+        logging.error(f"Error creating Gradio interface: {e}")
+        # Create a minimal fallback interface
+        with gr.Blocks() as demo:
+            gr.Markdown("# Typhoon Analysis Dashboard")
+            gr.Markdown("**Error**: Could not load full interface. Please check logs.")
+        return demo
+
+# Create and launch the interface
+demo = create_interface()
 
-# Fixed launch command
 if __name__ == "__main__":
     demo.launch()