Update app.py

app.py

@@ -48,21 +48,37 @@ logging.basicConfig(
 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()
-DATA_PATH = args.data_path
 
-# Update data paths for Huggingface Spaces
-TEMP_DIR = tempfile.gettempdir()
-DATA_PATH = os.environ.get('DATA_PATH', TEMP_DIR)
+# 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())
 
-# Ensure directory exists
-os.makedirs(DATA_PATH, exist_ok=True)
+# Ensure directory exists and is writable
+try:
+    os.makedirs(DATA_PATH, exist_ok=True)
+    # Test write permissions
+    test_file = os.path.join(DATA_PATH, 'test_write.txt')
+    with open(test_file, 'w') as f:
+        f.write('test')
+    os.remove(test_file)
+    logging.info(f"Data directory is writable: {DATA_PATH}")
+except Exception as e:
+    logging.warning(f"Data directory not writable, using temp dir: {e}")
+    DATA_PATH = tempfile.mkdtemp()
+    logging.info(f"Using temporary directory: {DATA_PATH}")
 
-# Update your file paths
+# Update file paths
 ONI_DATA_PATH = os.path.join(DATA_PATH, 'oni_data.csv')
 TYPHOON_DATA_PATH = os.path.join(DATA_PATH, 'processed_typhoon_data.csv')
 MERGED_DATA_CSV = os.path.join(DATA_PATH, 'merged_typhoon_era5_data.csv')
 
-# IBTrACS settings (for typhoon options)
+# IBTrACS settings
 BASIN_FILES = {
     'EP': 'ibtracs.EP.list.v04r01.csv',
     'NA': 'ibtracs.NA.list.v04r01.csv',
@@ -118,62 +134,295 @@ regions = {
     "Philippines": {"lat_min": 5, "lat_max": 21, "lon_min": 115, "lon_max": 130}
 }
 
+# -----------------------------
+# Utility Functions for HF Spaces
+# -----------------------------
+
+def safe_file_write(file_path, data_frame, backup_dir=None):
+    """Safely write DataFrame to CSV with backup and error handling"""
+    try:
+        # Create directory if it doesn't exist
+        os.makedirs(os.path.dirname(file_path), exist_ok=True)
+        
+        # Try to write to a temporary file first
+        temp_path = file_path + '.tmp'
+        data_frame.to_csv(temp_path, index=False)
+        
+        # If successful, rename to final file
+        os.rename(temp_path, file_path)
+        logging.info(f"Successfully saved {len(data_frame)} records to {file_path}")
+        return True
+        
+    except PermissionError as e:
+        logging.warning(f"Permission denied writing to {file_path}: {e}")
+        if backup_dir:
+            try:
+                backup_path = os.path.join(backup_dir, os.path.basename(file_path))
+                data_frame.to_csv(backup_path, index=False)
+                logging.info(f"Saved to backup location: {backup_path}")
+                return True
+            except Exception as backup_e:
+                logging.error(f"Failed to save to backup location: {backup_e}")
+        return False
+        
+    except Exception as e:
+        logging.error(f"Error saving file {file_path}: {e}")
+        # Clean up temp file if it exists
+        if os.path.exists(temp_path):
+            try:
+                os.remove(temp_path)
+            except:
+                pass
+        return False
+
+def get_fallback_data_dir():
+    """Get a fallback data directory that's guaranteed to be writable"""
+    fallback_dirs = [
+        tempfile.gettempdir(),
+        '/tmp',
+        os.path.expanduser('~'),
+        os.getcwd()
+    ]
+    
+    for directory in fallback_dirs:
+        try:
+            test_dir = os.path.join(directory, 'typhoon_fallback')
+            os.makedirs(test_dir, exist_ok=True)
+            test_file = os.path.join(test_dir, 'test.txt')
+            with open(test_file, 'w') as f:
+                f.write('test')
+            os.remove(test_file)
+            return test_dir
+        except:
+            continue
+    
+    # If all else fails, use current directory
+    return os.getcwd()
+
 # -----------------------------
 # ONI and Typhoon Data Functions
 # -----------------------------
+
 def download_oni_file(url, filename):
-    response = requests.get(url)
-    response.raise_for_status()
-    with open(filename, 'wb') as f:
-        f.write(response.content)
-    return True
+    """Download ONI file with retry logic"""
+    max_retries = 3
+    for attempt in range(max_retries):
+        try:
+            response = requests.get(url, timeout=30)
+            response.raise_for_status()
+            with open(filename, 'wb') as f:
+                f.write(response.content)
+            return True
+        except Exception as e:
+            logging.warning(f"Attempt {attempt + 1} failed to download ONI: {e}")
+            if attempt < max_retries - 1:
+                time.sleep(2 ** attempt)  # Exponential backoff
+            else:
+                logging.error(f"Failed to download ONI after {max_retries} attempts")
+                return False
 
 def convert_oni_ascii_to_csv(input_file, output_file):
+    """Convert ONI ASCII format to CSV"""
     data = defaultdict(lambda: [''] * 12)
     season_to_month = {'DJF':12, 'JFM':1, 'FMA':2, 'MAM':3, 'AMJ':4, 'MJJ':5,
                        'JJA':6, 'JAS':7, 'ASO':8, 'SON':9, 'OND':10, 'NDJ':11}
-    with open(input_file, 'r') as f:
-        lines = f.readlines()[1:]
-        for line in lines:
-            parts = line.split()
-            if len(parts) >= 4:
-                season, year, anom = parts[0], parts[1], parts[-1]
-                if season in season_to_month:
-                    month = season_to_month[season]
-                    if season == 'DJF':
-                        year = str(int(year)-1)
-                    data[year][month-1] = anom
-    with open(output_file, 'w', newline='') as f:
-        writer = csv.writer(f)
-        writer.writerow(['Year','Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'])
-        for year in sorted(data.keys()):
-            writer.writerow([year] + data[year])
+    
+    try:
+        with open(input_file, 'r') as f:
+            lines = f.readlines()[1:]  # Skip header
+            for line in lines:
+                parts = line.split()
+                if len(parts) >= 4:
+                    season, year, anom = parts[0], parts[1], parts[-1]
+                    if season in season_to_month:
+                        month = season_to_month[season]
+                        if season == 'DJF':
+                            year = str(int(year)-1)
+                        data[year][month-1] = anom
+        
+        # Write to CSV with safe write
+        df = pd.DataFrame(data).T.reset_index()
+        df.columns = ['Year','Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec']
+        df = df.sort_values('Year').reset_index(drop=True)
+        
+        return safe_file_write(output_file, df, get_fallback_data_dir())
+        
+    except Exception as e:
+        logging.error(f"Error converting ONI file: {e}")
+        return False
 
 def update_oni_data():
+    """Update ONI data with error handling"""
     url = "https://www.cpc.ncep.noaa.gov/data/indices/oni.ascii.txt"
     temp_file = os.path.join(DATA_PATH, "temp_oni.ascii.txt")
     input_file = os.path.join(DATA_PATH, "oni.ascii.txt")
     output_file = ONI_DATA_PATH
-    if download_oni_file(url, temp_file):
-        if not os.path.exists(input_file) or not os.path.exists(output_file):
-            os.replace(temp_file, input_file)
-            convert_oni_ascii_to_csv(input_file, output_file)
+    
+    try:
+        if download_oni_file(url, temp_file):
+            if not os.path.exists(input_file) or not os.path.exists(output_file):
+                os.rename(temp_file, input_file)
+                convert_oni_ascii_to_csv(input_file, output_file)
+            else:
+                os.remove(temp_file)
         else:
-            os.remove(temp_file)
+            # Create fallback ONI data if download fails
+            logging.warning("Creating fallback ONI data")
+            create_fallback_oni_data(output_file)
+    except Exception as e:
+        logging.error(f"Error updating ONI data: {e}")
+        create_fallback_oni_data(output_file)
+
+def create_fallback_oni_data(output_file):
+    """Create minimal ONI data for testing"""
+    years = range(2000, 2025)
+    months = ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec']
+    
+    # Create synthetic ONI data
+    data = []
+    for year in years:
+        row = [year]
+        for month in months:
+            # Generate some realistic ONI values
+            value = np.random.normal(0, 1) * 0.5
+            row.append(f"{value:.2f}")
+        data.append(row)
+    
+    df = pd.DataFrame(data, columns=['Year'] + months)
+    safe_file_write(output_file, df, get_fallback_data_dir())
+
+# -----------------------------
+# FIXED: IBTrACS Data Loading
+# -----------------------------
+
+def download_ibtracs_file(basin, force_download=False):
+    """Download specific basin file from IBTrACS"""
+    filename = BASIN_FILES[basin]
+    local_path = os.path.join(DATA_PATH, filename)
+    url = IBTRACS_BASE_URL + filename
+    
+    # Check if file exists and is recent (less than 7 days old)
+    if os.path.exists(local_path) and not force_download:
+        file_age = time.time() - os.path.getmtime(local_path)
+        if file_age < 7 * 24 * 3600:  # 7 days
+            logging.info(f"Using cached {basin} basin file")
+            return local_path
+    
+    try:
+        logging.info(f"Downloading {basin} basin file from {url}")
+        response = requests.get(url, timeout=60)
+        response.raise_for_status()
+        
+        # Ensure directory exists
+        os.makedirs(os.path.dirname(local_path), exist_ok=True)
+        
+        with open(local_path, 'wb') as f:
+            f.write(response.content)
+        logging.info(f"Successfully downloaded {basin} basin file")
+        return local_path
+    except Exception as e:
+        logging.error(f"Failed to download {basin} basin file: {e}")
+        return None
+
+def load_ibtracs_csv_directly(basin='WP'):
+    """Load IBTrACS data directly from CSV without tropycal"""
+    filename = BASIN_FILES[basin]
+    local_path = os.path.join(DATA_PATH, filename)
+    
+    # Download if not exists
+    if not os.path.exists(local_path):
+        downloaded_path = download_ibtracs_file(basin)
+        if not downloaded_path:
+            return None
+    
+    try:
+        # Read IBTrACS CSV with specific parameters
+        essential_columns = [
+            'SID', 'SEASON', 'NUMBER', 'BASIN', 'SUBBASIN', 'NAME', 
+            'ISO_TIME', 'NATURE', 'LAT', 'LON', 'WMO_WIND', 'WMO_PRES',
+            'USA_WIND', 'USA_PRES', 'USA_STATUS', 'USA_R34_NE', 'USA_R34_SE',
+            'USA_R34_SW', 'USA_R34_NW', 'USA_R50_NE', 'USA_R50_SE', 
+            'USA_R50_SW', 'USA_R50_NW', 'USA_R64_NE', 'USA_R64_SE',
+            'USA_R64_SW', 'USA_R64_NW', 'USA_RMW', 'USA_EYE'
+        ]
+        
+        # Read with error handling for missing columns
+        logging.info(f"Reading IBTrACS CSV file: {local_path}")
+        df = pd.read_csv(local_path, low_memory=False, skiprows=1)  # Skip header row with units
+        
+        # Check which essential columns exist
+        available_columns = [col for col in essential_columns if col in df.columns]
+        missing_columns = [col for col in essential_columns if col not in df.columns]
+        
+        if missing_columns:
+            logging.warning(f"Missing columns in IBTrACS data: {missing_columns}")
+        
+        # Select only available columns
+        df = df[available_columns].copy()
+        
+        # Clean and standardize the data
+        # Convert ISO_TIME to datetime
+        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']
+        for col in numeric_columns:
+            if col in df.columns:
+                df[col] = pd.to_numeric(df[col], errors='coerce')
+        
+        # Filter out invalid/missing critical data
+        df = df.dropna(subset=['ISO_TIME', 'LAT', 'LON'])
+        
+        # Ensure LAT/LON are in reasonable ranges
+        df = df[(df['LAT'] >= -90) & (df['LAT'] <= 90)]
+        df = df[(df['LON'] >= -180) & (df['LON'] <= 180)]
+        
+        logging.info(f"Successfully loaded {len(df)} records from {basin} basin")
+        return df
+        
+    except Exception as e:
+        logging.error(f"Error reading IBTrACS CSV file: {e}")
+        return None
+
+def load_ibtracs_data_fixed():
+    """Fixed version of IBTrACS data loading"""
+    ibtracs_data = {}
+    
+    # Try to load each basin, but prioritize WP for this application
+    load_order = ['WP', 'EP', 'NA']
+    
+    for basin in load_order:
+        try:
+            logging.info(f"Loading {basin} basin data...")
+            df = load_ibtracs_csv_directly(basin)
+            
+            if df is not None and not df.empty:
+                ibtracs_data[basin] = df
+                logging.info(f"Successfully loaded {basin} basin with {len(df)} records")
+            else:
+                logging.warning(f"No data loaded for basin {basin}")
+                ibtracs_data[basin] = None
+                
+        except Exception as e:
+            logging.error(f"Failed to load basin {basin}: {e}")
+            ibtracs_data[basin] = None
+    
+    return ibtracs_data
 
-def load_data(oni_path, typhoon_path):
-    # Create default empty DataFrames with minimum structure
+def load_data_fixed(oni_path, typhoon_path):
+    """Fixed version of load_data function"""
+    # Load ONI data
     oni_data = pd.DataFrame({'Year': [], 'Jan': [], 'Feb': [], 'Mar': [], 'Apr': [], 
                            'May': [], 'Jun': [], 'Jul': [], 'Aug': [], 'Sep': [], 
                            'Oct': [], 'Nov': [], 'Dec': []})
     
-    # Try to load ONI data or create it
     if not os.path.exists(oni_path):
         logging.warning(f"ONI data file not found: {oni_path}")
         update_oni_data()
     
     try:
         oni_data = pd.read_csv(oni_path)
+        logging.info(f"Successfully loaded ONI data with {len(oni_data)} years")
     except Exception as e:
         logging.error(f"Error loading ONI data: {e}")
         update_oni_data()
@@ -182,56 +431,127 @@ def load_data(oni_path, typhoon_path):
         except Exception as e:
             logging.error(f"Still can't load ONI data: {e}")
     
-    # For typhoon data, focus on getting WP data
+    # Load typhoon data - NEW APPROACH
+    typhoon_data = None
+    
+    # First, try to load from existing processed file
     if os.path.exists(typhoon_path):
         try:
             typhoon_data = pd.read_csv(typhoon_path, low_memory=False)
-            typhoon_data['ISO_TIME'] = pd.to_datetime(typhoon_data['ISO_TIME'], errors='coerce')
-            typhoon_data = typhoon_data.dropna(subset=['ISO_TIME'])
-            # Log WP data count
-            wp_count = len(typhoon_data[typhoon_data['SID'].str.startswith('WP')])
-            logging.info(f"Loaded {wp_count} Western Pacific typhoon records")
-        except Exception as e:
-            logging.error(f"Error loading typhoon data: {e}")
-            typhoon_data = pd.DataFrame()
-    else:
-        logging.error(f"Typhoon data file not found: {typhoon_path}")
-        # Download WP typhoon data directly from IBTrACS if available
-        try:
-            if LOCAL_IBTRACS_PATH and os.path.exists(LOCAL_IBTRACS_PATH):
-                logging.info("Loading WP data from local IBTrACS file")
-                wp_data = pd.read_csv(LOCAL_IBTRACS_PATH, low_memory=False)
-                typhoon_data = wp_data
-                logging.info(f"Loaded {len(typhoon_data)} WP records from IBTrACS")
+            # Ensure basic columns exist and are valid
+            required_cols = ['SID', 'ISO_TIME', 'LAT', 'LON']
+            if all(col in typhoon_data.columns for col in required_cols):
+                typhoon_data['ISO_TIME'] = pd.to_datetime(typhoon_data['ISO_TIME'], errors='coerce')
+                typhoon_data = typhoon_data.dropna(subset=['ISO_TIME'])
+                logging.info(f"Loaded processed typhoon data with {len(typhoon_data)} records")
             else:
-                # Try to download WP file if not exists
-                logging.info("Downloading WP basin file...")
-                response = requests.get(IBTRACS_BASE_URL + BASIN_FILES['WP'])
-                if response.status_code == 200:
-                    os.makedirs(os.path.dirname(LOCAL_IBTRACS_PATH), exist_ok=True)
-                    with open(LOCAL_IBTRACS_PATH, 'wb') as f:
-                        f.write(response.content)
-                    wp_data = pd.read_csv(LOCAL_IBTRACS_PATH, low_memory=False)
-                    typhoon_data = wp_data
-                    logging.info(f"Downloaded and loaded {len(typhoon_data)} WP records")
+                logging.warning("Processed typhoon data missing required columns, will reload from IBTrACS")
+                typhoon_data = None
         except Exception as e:
-            logging.error(f"Failed to load or download WP data: {e}")
-            # Create minimal WP sample data to prevent crashes
-            typhoon_data = pd.DataFrame({
-                'SID': ['WP012000', 'WP022000', 'WP032000'], 
-                'ISO_TIME': [pd.Timestamp('2000-01-01'), pd.Timestamp('2000-02-01'), pd.Timestamp('2000-03-01')],
-                'NAME': ['SAMPLE_WP1', 'SAMPLE_WP2', 'SAMPLE_WP3'],
-                'SEASON': [2000, 2000, 2000],
-                'LAT': [20.0, 21.0, 22.0],
-                'LON': [140.0, 141.0, 142.0],
-                'USA_WIND': [50.0, 60.0, 70.0],
-                'USA_PRES': [990.0, 980.0, 970.0]
-            })
-            logging.warning("Created minimal Western Pacific sample data to prevent crashes")
+            logging.error(f"Error loading processed typhoon data: {e}")
+            typhoon_data = None
+    
+    # If no valid processed data, load from IBTrACS
+    if typhoon_data is None or typhoon_data.empty:
+        logging.info("Loading typhoon data from IBTrACS...")
+        ibtracs_data = load_ibtracs_data_fixed()
+        
+        # Combine all available basin data, prioritizing WP
+        combined_dfs = []
+        for basin in ['WP', 'EP', 'NA']:
+            if basin in ibtracs_data and ibtracs_data[basin] is not None:
+                df = ibtracs_data[basin].copy()
+                df['BASIN'] = basin
+                combined_dfs.append(df)
+        
+        if combined_dfs:
+            typhoon_data = pd.concat(combined_dfs, ignore_index=True)
+            # Ensure SID has proper format
+            if 'SID' not in typhoon_data.columns and 'BASIN' in typhoon_data.columns:
+                # Create SID from basin and other identifiers if missing
+                if 'NUMBER' in typhoon_data.columns and 'SEASON' in typhoon_data.columns:
+                    typhoon_data['SID'] = (typhoon_data['BASIN'].astype(str) + 
+                                         typhoon_data['NUMBER'].astype(str).str.zfill(2) + 
+                                         typhoon_data['SEASON'].astype(str))
+            
+            # Save the processed data for future use
+            safe_file_write(typhoon_path, typhoon_data, get_fallback_data_dir())
+            logging.info(f"Combined IBTrACS data: {len(typhoon_data)} total records")
+        else:
+            logging.error("Failed to load any IBTrACS basin data")
+            # Create minimal fallback data
+            typhoon_data = create_fallback_typhoon_data()
+    
+    # Final validation of typhoon data
+    if typhoon_data is not None:
+        # Ensure required columns exist with fallback values
+        required_columns = {
+            'SID': 'UNKNOWN',
+            'ISO_TIME': pd.Timestamp('2000-01-01'),
+            'LAT': 0.0,
+            'LON': 0.0,
+            'USA_WIND': np.nan,
+            'USA_PRES': np.nan,
+            'NAME': 'UNNAMED',
+            'SEASON': 2000
+        }
+        
+        for col, default_val in required_columns.items():
+            if col not in typhoon_data.columns:
+                typhoon_data[col] = default_val
+                logging.warning(f"Added missing column {col} with default value")
+        
+        # Ensure data types
+        typhoon_data['ISO_TIME'] = pd.to_datetime(typhoon_data['ISO_TIME'], errors='coerce')
+        typhoon_data['LAT'] = pd.to_numeric(typhoon_data['LAT'], errors='coerce')
+        typhoon_data['LON'] = pd.to_numeric(typhoon_data['LON'], errors='coerce')
+        typhoon_data['USA_WIND'] = pd.to_numeric(typhoon_data['USA_WIND'], errors='coerce')
+        typhoon_data['USA_PRES'] = pd.to_numeric(typhoon_data['USA_PRES'], errors='coerce')
+        
+        # Remove rows with invalid times or coordinates
+        typhoon_data = typhoon_data.dropna(subset=['ISO_TIME', 'LAT', 'LON'])
+        
+        logging.info(f"Final typhoon data: {len(typhoon_data)} records after validation")
     
     return oni_data, typhoon_data
 
+def create_fallback_typhoon_data():
+    """Create minimal fallback typhoon data"""
+    dates = pd.date_range(start='2000-01-01', end='2023-12-31', freq='D')
+    storm_dates = np.random.choice(dates, size=100, replace=False)
+    
+    data = []
+    for i, date in enumerate(storm_dates):
+        # Create realistic WP storm tracks
+        base_lat = np.random.uniform(10, 30)
+        base_lon = np.random.uniform(130, 160)
+        
+        # Generate 20-50 data points per storm
+        track_length = np.random.randint(20, 51)
+        sid = f"WP{i+1:02d}{date.year}"
+        
+        for j in range(track_length):
+            lat = base_lat + j * 0.2 + np.random.normal(0, 0.1)
+            lon = base_lon + j * 0.3 + np.random.normal(0, 0.1)
+            wind = max(25, 70 + np.random.normal(0, 20))
+            pres = max(950, 1000 - wind + np.random.normal(0, 5))
+            
+            data.append({
+                'SID': sid,
+                'ISO_TIME': date + timedelta(hours=j*6),
+                'NAME': f'FALLBACK_{i+1}',
+                'SEASON': date.year,
+                'LAT': lat,
+                'LON': lon,
+                'USA_WIND': wind,
+                'USA_PRES': pres,
+                'BASIN': 'WP'
+            })
+    
+    return pd.DataFrame(data)
+
 def process_oni_data(oni_data):
+    """Process ONI data into long format"""
     oni_long = oni_data.melt(id_vars=['Year'], var_name='Month', value_name='ONI')
     month_map = {'Jan':'01','Feb':'02','Mar':'03','Apr':'04','May':'05','Jun':'06',
                  'Jul':'07','Aug':'08','Sep':'09','Oct':'10','Nov':'11','Dec':'12'}
@@ -241,24 +561,30 @@ def process_oni_data(oni_data):
     return oni_long
 
 def process_typhoon_data(typhoon_data):
+    """Process typhoon data"""
     typhoon_data['ISO_TIME'] = pd.to_datetime(typhoon_data['ISO_TIME'], errors='coerce')
     typhoon_data['USA_WIND'] = pd.to_numeric(typhoon_data['USA_WIND'], errors='coerce')
     typhoon_data['USA_PRES'] = pd.to_numeric(typhoon_data['USA_PRES'], errors='coerce')
     typhoon_data['LON'] = pd.to_numeric(typhoon_data['LON'], errors='coerce')
+    
     logging.info(f"Unique basins in typhoon_data: {typhoon_data['SID'].str[:2].unique()}")
+    
     typhoon_max = typhoon_data.groupby('SID').agg({
         'USA_WIND':'max','USA_PRES':'min','ISO_TIME':'first','SEASON':'first','NAME':'first',
         'LAT':'first','LON':'first'
     }).reset_index()
+    
     typhoon_max['Month'] = typhoon_max['ISO_TIME'].dt.strftime('%m')
     typhoon_max['Year'] = typhoon_max['ISO_TIME'].dt.year
     typhoon_max['Category'] = typhoon_max['USA_WIND'].apply(categorize_typhoon)
     return typhoon_max
 
 def merge_data(oni_long, typhoon_max):
+    """Merge ONI and typhoon data"""
     return pd.merge(typhoon_max, oni_long, on=['Year','Month'])
 
 def categorize_typhoon(wind_speed):
+    """Categorize typhoon based on wind speed"""
     if wind_speed >= 137:
         return 'C5 Super Typhoon'
     elif wind_speed >= 113:
@@ -275,6 +601,7 @@ def categorize_typhoon(wind_speed):
         return 'Tropical Depression'
 
 def classify_enso_phases(oni_value):
+    """Classify ENSO phases based on ONI value"""
     if isinstance(oni_value, pd.Series):
         oni_value = oni_value.iloc[0]
     if oni_value >= 0.5:
@@ -287,84 +614,64 @@ def classify_enso_phases(oni_value):
 # -----------------------------
 # Regression Functions
 # -----------------------------
+
 def perform_wind_regression(start_year, start_month, end_year, end_month):
+    """Perform wind regression analysis"""
     start_date = datetime(start_year, start_month, 1)
     end_date = datetime(end_year, end_month, 28)
     data = merged_data[(merged_data['ISO_TIME']>=start_date) & (merged_data['ISO_TIME']<=end_date)].dropna(subset=['USA_WIND','ONI'])
     data['severe_typhoon'] = (data['USA_WIND']>=64).astype(int)
     X = sm.add_constant(data['ONI'])
     y = data['severe_typhoon']
-    model = sm.Logit(y, X).fit(disp=0)
-    beta_1 = model.params['ONI']
-    exp_beta_1 = np.exp(beta_1)
-    p_value = model.pvalues['ONI']
-    return f"Wind Regression: β1={beta_1:.4f}, Odds Ratio={exp_beta_1:.4f}, P-value={p_value:.4f}"
+    try:
+        model = sm.Logit(y, X).fit(disp=0)
+        beta_1 = model.params['ONI']
+        exp_beta_1 = np.exp(beta_1)
+        p_value = model.pvalues['ONI']
+        return f"Wind Regression: β1={beta_1:.4f}, Odds Ratio={exp_beta_1:.4f}, P-value={p_value:.4f}"
+    except Exception as e:
+        return f"Wind Regression Error: {e}"
 
 def perform_pressure_regression(start_year, start_month, end_year, end_month):
+    """Perform pressure regression analysis"""
     start_date = datetime(start_year, start_month, 1)
     end_date = datetime(end_year, end_month, 28)
     data = merged_data[(merged_data['ISO_TIME']>=start_date) & (merged_data['ISO_TIME']<=end_date)].dropna(subset=['USA_PRES','ONI'])
     data['intense_typhoon'] = (data['USA_PRES']<=950).astype(int)
     X = sm.add_constant(data['ONI'])
     y = data['intense_typhoon']
-    model = sm.Logit(y, X).fit(disp=0)
-    beta_1 = model.params['ONI']
-    exp_beta_1 = np.exp(beta_1)
-    p_value = model.pvalues['ONI']
-    return f"Pressure Regression: β1={beta_1:.4f}, Odds Ratio={exp_beta_1:.4f}, P-value={p_value:.4f}"
+    try:
+        model = sm.Logit(y, X).fit(disp=0)
+        beta_1 = model.params['ONI']
+        exp_beta_1 = np.exp(beta_1)
+        p_value = model.pvalues['ONI']
+        return f"Pressure Regression: β1={beta_1:.4f}, Odds Ratio={exp_beta_1:.4f}, P-value={p_value:.4f}"
+    except Exception as e:
+        return f"Pressure Regression Error: {e}"
 
 def perform_longitude_regression(start_year, start_month, end_year, end_month):
+    """Perform longitude regression analysis"""
     start_date = datetime(start_year, start_month, 1)
     end_date = datetime(end_year, end_month, 28)
     data = merged_data[(merged_data['ISO_TIME']>=start_date) & (merged_data['ISO_TIME']<=end_date)].dropna(subset=['LON','ONI'])
     data['western_typhoon'] = (data['LON']<=140).astype(int)
     X = sm.add_constant(data['ONI'])
     y = data['western_typhoon']
-    model = sm.OLS(y, sm.add_constant(X)).fit()
-    beta_1 = model.params['ONI']
-    exp_beta_1 = np.exp(beta_1)
-    p_value = model.pvalues['ONI']
-    return f"Longitude Regression: β1={beta_1:.4f}, Odds Ratio={exp_beta_1:.4f}, P-value={p_value:.4f}"
-
-# -----------------------------
-# IBTrACS Data Loading
-# -----------------------------
-def load_ibtracs_data():
-    ibtracs_data = {}
-    for basin, filename in BASIN_FILES.items():
-        local_path = os.path.join(DATA_PATH, filename)
-        if not os.path.exists(local_path):
-            logging.info(f"Downloading {basin} basin file...")
-            response = requests.get(IBTRACS_BASE_URL+filename)
-            response.raise_for_status()
-            with open(local_path, 'wb') as f:
-                f.write(response.content)
-            logging.info(f"Downloaded {basin} basin file.")
-        try:
-            logging.info(f"--> Starting to read in IBTrACS data for basin {basin}")
-            ds = tracks.TrackDataset(source='ibtracs', ibtracs_url=local_path)
-            logging.info(f"--> Completed reading in IBTrACS data for basin {basin}")
-            ibtracs_data[basin] = ds
-        except ValueError as e:
-            logging.warning(f"Skipping basin {basin} due to error: {e}")
-            ibtracs_data[basin] = None
-    return ibtracs_data
-
-ibtracs = load_ibtracs_data()
-
-# -----------------------------
-# Load & Process Data
-# -----------------------------
-update_oni_data()
-oni_data, typhoon_data = load_data(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)
+    try:
+        model = sm.OLS(y, sm.add_constant(X)).fit()
+        beta_1 = model.params['ONI']
+        exp_beta_1 = np.exp(beta_1)
+        p_value = model.pvalues['ONI']
+        return f"Longitude Regression: β1={beta_1:.4f}, Odds Ratio={exp_beta_1:.4f}, P-value={p_value:.4f}"
+    except Exception as e:
+        return f"Longitude Regression Error: {e}"
 
 # -----------------------------
 # 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]
@@ -390,6 +697,7 @@ def generate_typhoon_tracks(filtered_data, typhoon_search):
     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',
@@ -407,6 +715,7 @@ def generate_wind_oni_scatter(filtered_data, typhoon_search):
     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',
@@ -424,21 +733,26 @@ def generate_pressure_oni_scatter(filtered_data, typhoon_search):
     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']
-        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}"
+        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()
@@ -452,6 +766,7 @@ def generate_main_analysis(start_year, start_month, end_year, end_month, enso_ph
     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)
     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()
@@ -464,7 +779,7 @@ def get_full_tracks(start_year, start_month, end_year, end_month, enso_phase, ty
     for sid in unique_storms:
         storm_data = typhoon_data[typhoon_data['SID']==sid]
         name = storm_data['NAME'].iloc[0] if pd.notnull(storm_data['NAME'].iloc[0]) else "Unnamed"
-        basin = storm_data['SID'].iloc[0][:2]  # First 2 characters often denote basin
+        basin = storm_data['SID'].iloc[0][:2]
         storm_oni = filtered_data[filtered_data['SID']==sid]['ONI'].iloc[0]
         color = 'red' if storm_oni>=0.5 else ('blue' if storm_oni<=-0.5 else 'green')
         fig.add_trace(go.Scattergeo(
@@ -508,21 +823,25 @@ def get_full_tracks(start_year, start_month, end_year, end_month, enso_phase, ty
     return fig, f"Total typhoons displayed: {count}"
 
 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)
     regression = perform_wind_regression(start_year, start_month, end_year, end_month)
     return results[1], 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)
     regression = perform_pressure_regression(start_year, start_month, end_year, end_month)
     return results[2], 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)
     regression = perform_longitude_regression(start_year, start_month, end_year, end_month)
     return results[3], results[4], regression
 
 def categorize_typhoon_by_standard(wind_speed, standard='atlantic'):
+    """Categorize typhoon by standard"""
     if standard=='taiwan':
         wind_speed_ms = wind_speed * 0.514444
         if wind_speed_ms >= 51.0:
@@ -548,11 +867,13 @@ def categorize_typhoon_by_standard(wind_speed, standard='atlantic'):
         return 'Tropical Depression', atlantic_standard['Tropical Depression']['hex']
 
 # -----------------------------
-# Updated TSNE Cluster Function with Mean Curves
+# 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 so each storm has multiple observations.
+        # Merge raw typhoon data with ONI
         raw_data = typhoon_data.copy()
         raw_data['Year'] = raw_data['ISO_TIME'].dt.year
         raw_data['Month'] = raw_data['ISO_TIME'].dt.strftime('%m')
@@ -578,7 +899,7 @@ def update_route_clusters(start_year, start_month, end_year, end_month, enso_val
             logging.info("WP regional filter returned no data; using all filtered data.")
             wp_data = merged_raw
         
-        # Group by storm ID so each storm has multiple observations
+        # Group by storm ID
         all_storms_data = []
         for sid, group in wp_data.groupby('SID'):
             group = group.sort_values('ISO_TIME')
@@ -587,20 +908,22 @@ def update_route_clusters(start_year, start_month, end_year, end_month, enso_val
             lons = group['LON'].astype(float).values
             if len(lons) < 2:
                 continue
-            # Also extract wind and pressure curves
+            # 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, wind, and pressure to a common length
+        # Interpolate each storm's route to a common length
         max_length = max(len(item[1]) for item in all_storms_data)
         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)
@@ -610,12 +933,15 @@ def update_route_clusters(start_year, start_month, end_year, end_month, enso_val
             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 available
+            
+            # 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)
@@ -624,6 +950,7 @@ def update_route_clusters(start_year, start_month, end_year, end_month, enso_val
                     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)
@@ -632,8 +959,10 @@ def update_route_clusters(start_year, start_month, end_year, end_month, enso_val
                     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."
@@ -646,7 +975,7 @@ def update_route_clusters(start_year, start_month, end_year, end_month, enso_val
         tsne = TSNE(n_components=2, random_state=42, verbose=1)
         tsne_results = tsne.fit_transform(route_vectors)
         
-        # Dynamic DBSCAN: choose eps to yield roughly 5 to 20 clusters
+        # Dynamic DBSCAN
         selected_labels = None
         selected_eps = None
         for eps in np.linspace(1.0, 10.0, 91):
@@ -657,16 +986,19 @@ def update_route_clusters(start_year, start_month, end_year, end_month, enso_val
                 selected_labels = labels
                 selected_eps = eps
                 break
+        
         if selected_labels is None:
             selected_eps = 5.0
             dbscan = DBSCAN(eps=selected_eps, min_samples=3)
             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.Safe
         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(
@@ -676,6 +1008,7 @@ def update_route_clusters(start_year, start_month, end_year, end_month, enso_val
                 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(
@@ -685,15 +1018,17 @@ def update_route_clusters(start_year, start_month, end_year, end_month, enso_val
                 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"
         )
         
-        # For each cluster, compute mean route, and compute mean wind and pressure curves along normalized route index.
+        # Compute mean routes and curves for each cluster
         fig_routes = go.Figure()
-        cluster_stats = []  # To hold mean curves per cluster
+        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]
@@ -702,6 +1037,7 @@ def update_route_clusters(start_year, start_month, end_year, end_month, enso_val
             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,
@@ -709,17 +1045,19 @@ def update_route_clusters(start_year, start_month, end_year, end_month, enso_val
                 line=dict(width=4, color=colors[i % len(colors)]),
                 name=f"Cluster {label} Mean Route"
             ))
-            # Retrieve raw wind and pressure curves for storms in this cluster
+            
+            # 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))
         
-        # Create a cluster stats plot with curves vs normalized route index (0 to 1)
+        # 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,
@@ -728,6 +1066,7 @@ def update_route_clusters(start_year, start_month, end_year, end_month, enso_val
                 line=dict(width=2, color=colors[i % len(colors)]),
                 name=f"Cluster {label} Mean Wind"
             ), row=1, col=1)
+            
             fig_stats.add_trace(go.Scatter(
                 x=x_axis,
                 y=pres_curve,
@@ -735,6 +1074,7 @@ def update_route_clusters(start_year, start_month, end_year, end_month, enso_val
                 line=dict(width=2, color=colors[i % len(colors)]),
                 name=f"Cluster {label} Mean MSLP"
             ), row=2, col=1)
+        
         fig_stats.update_layout(
             title="Cluster Mean Curves",
             xaxis_title="Normalized Route Index",
@@ -746,28 +1086,34 @@ def update_route_clusters(start_year, start_month, end_year, end_month, enso_val
         
         info = f"TSNE clustering complete. Selected eps: {selected_eps:.2f}. Clusters: {len(unique_labels)}."
         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 Using Processed CSV & Stock Map
+# Animation Functions
 # -----------------------------
+
 def generate_track_video_from_csv(year, storm_id, standard):
+    """Generate track video from CSV data"""
     storm_df = typhoon_data[typhoon_data['SID'] == storm_id].copy()
     if storm_df.empty:
         logging.error(f"No data found for storm: {storm_id}")
         return None
+    
     storm_df = storm_df.sort_values('ISO_TIME')
     lats = storm_df['LAT'].astype(float).values
     lons = storm_df['LON'].astype(float).values
     times = pd.to_datetime(storm_df['ISO_TIME']).values
+    
     if 'USA_WIND' in storm_df.columns:
         winds = pd.to_numeric(storm_df['USA_WIND'], errors='coerce').values
     else:
         winds = np.full(len(lats), np.nan)
+    
     storm_name = storm_df['NAME'].iloc[0]
-    basin = storm_df['SID'].iloc[0][:2]  # Use first 2 characters as basin code
+    basin = storm_df['SID'].iloc[0][:2]
     season = storm_df['SEASON'].iloc[0]
     
     min_lat, max_lat = np.min(lats), np.max(lats)
@@ -790,7 +1136,6 @@ def generate_track_video_from_csv(year, storm_id, standard):
     point, = ax.plot([], [], 'o', markersize=8, transform=ccrs.PlateCarree())
     date_text = ax.text(0.02, 0.02, '', transform=ax.transAxes, fontsize=10,
                         bbox=dict(facecolor='white', alpha=0.8))
-    # Display storm name and basin in a dynamic sidebar
     storm_info_text = fig.text(0.70, 0.60, '', fontsize=10,
                                bbox=dict(facecolor='white', alpha=0.8, boxstyle='round,pad=0.5'))
     
@@ -823,87 +1168,90 @@ def generate_track_video_from_csv(year, storm_id, standard):
 
     ani = animation.FuncAnimation(fig, update, init_func=init, frames=len(times),
                                   interval=200, blit=True, repeat=True)
-    temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.mp4')
-    writer = animation.FFMpegWriter(fps=5, bitrate=1800)
-    ani.save(temp_file.name, writer=writer)
-    plt.close(fig)
-    return temp_file.name
+    
+    # Create animation file
+    temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.mp4', dir=DATA_PATH)
+    try:
+        writer = animation.FFMpegWriter(fps=5, bitrate=1800)
+        ani.save(temp_file.name, writer=writer)
+        plt.close(fig)
+        return temp_file.name
+    except Exception as e:
+        logging.error(f"Error creating animation: {e}")
+        plt.close(fig)
+        return None
 
 def simplified_track_video(year, basin, typhoon, standard):
+    """Simplified track video function"""
     if not typhoon:
         return None
     storm_id = typhoon.split('(')[-1].strip(')')
     return generate_track_video_from_csv(year, storm_id, standard)
 
 # -----------------------------
-# Typhoon Options Update Functions
+# FIXED: Update Typhoon Options Function 
 # -----------------------------
-basin_to_prefix = {
-    "All Basins": "all",
-    "NA - North Atlantic": "NA",
-    "EP - Eastern North Pacific": "EP",
-    "WP - Western North Pacific": "WP"
-}
 
-def update_typhoon_options(year, basin):
+def update_typhoon_options_fixed(year, basin):
+    """Fixed version of update_typhoon_options"""
     try:
-        if basin == "All Basins":
-            summaries = []
-            for data in ibtracs.values():
-                if data is not None:
-                    season_data = data.get_season(int(year))
-                    if season_data.summary().empty:
-                        continue
-                    summaries.append(season_data.summary())
-            if len(summaries) == 0:
-                logging.error("No storms found for given year and basin.")
-                return gr.update(choices=[], value=None)
-            combined_summary = pd.concat(summaries, ignore_index=True)
-        else:
-            prefix = basin_to_prefix.get(basin)
-            ds = ibtracs.get(prefix)
-            if ds is None:
-                logging.error(f"Dataset not found for basin {basin}")
-                return gr.update(choices=[], value=None)
-            season_data = ds.get_season(int(year))
-            if season_data.summary().empty:
-                logging.error("No storms found for given year and basin.")
-                return gr.update(choices=[], value=None)
-            combined_summary = season_data.summary()
-        options = []
-        for i in range(len(combined_summary)):
-            try:
-                name = combined_summary['name'][i] if pd.notnull(combined_summary['name'][i]) else "Unnamed"
-                storm_id = combined_summary['id'][i]
-                options.append(f"{name} ({storm_id})")
-            except Exception:
-                continue
-        return gr.update(choices=options, value=options[0] if options else None)
-    except Exception as e:
-        logging.error(f"Error in update_typhoon_options: {e}")
-        return gr.update(choices=[], value=None)
-
-def update_typhoon_options_anim(year, basin):
-    try:
-        data = typhoon_data.copy()
-        data['Year'] = data['ISO_TIME'].dt.year
-        season_data = data[data['Year'] == int(year)]
-        if season_data.empty:
-            logging.error(f"No storms found for year {year} in animation update.")
+        # Use the typhoon_data already loaded
+        if typhoon_data is None or typhoon_data.empty:
+            logging.error("No typhoon data available")
+            return gr.update(choices=[], value=None)
+        
+        # Filter by year
+        year_data = typhoon_data[typhoon_data['ISO_TIME'].dt.year == int(year)].copy()
+        
+        if basin != "All Basins":
+            # Extract basin code
+            basin_code = basin.split(' - ')[0] if ' - ' in basin else basin[:2]
+            # Filter by basin
+            if 'SID' in year_data.columns:
+                year_data = year_data[year_data['SID'].str.startswith(basin_code, na=False)]
+            elif 'BASIN' in year_data.columns:
+                year_data = year_data[year_data['BASIN'] == basin_code]
+        
+        if year_data.empty:
+            logging.warning(f"No storms found for year {year} and basin {basin}")
             return gr.update(choices=[], value=None)
-        summary = season_data.groupby('SID').first().reset_index()
+        
+        # Get unique storms and create options
+        storms = year_data.groupby('SID').first().reset_index()
         options = []
-        for idx, row in summary.iterrows():
-            name = row['NAME'] if pd.notnull(row['NAME']) else "Unnamed"
-            options.append(f"{name} ({row['SID']})")
-        return gr.update(choices=options, value=options[0] if options else None)
+        
+        for _, storm in storms.iterrows():
+            name = storm.get('NAME', 'UNNAMED')
+            if pd.isna(name) or name == '':
+                name = 'UNNAMED'
+            sid = storm['SID']
+            options.append(f"{name} ({sid})")
+        
+        if not options:
+            return gr.update(choices=[], value=None)
+            
+        return gr.update(choices=sorted(options), value=options[0])
+        
     except Exception as e:
-        logging.error(f"Error in update_typhoon_options_anim: {e}")
+        logging.error(f"Error in update_typhoon_options_fixed: {e}")
         return gr.update(choices=[], value=None)
 
+# -----------------------------
+# Load & Process Data (using fixed functions)
+# -----------------------------
+
+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.")
+
 # -----------------------------
 # Gradio Interface
 # -----------------------------
+
 with gr.Blocks(title="Typhoon Analysis Dashboard") as demo:
     gr.Markdown("# Typhoon Analysis Dashboard")
     
@@ -918,10 +1266,14 @@ with gr.Blocks(title="Typhoon Analysis Dashboard") as demo:
         - **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 free stock world map (centered at 180°) with a dynamic sidebar that shows the typhoon name and basin.
-        - **TSNE Cluster**: Perform t-SNE clustering on WP storm routes using raw merged typhoon+ONI data with detailed error management.
-          Mean routes and evolving curves (wind and pressure vs. normalized route index) are computed.
-        """)
+        - **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)))
 
     with gr.Tab("Track Visualization"):
         with gr.Row():
@@ -987,7 +1339,6 @@ with gr.Blocks(title="Typhoon Analysis Dashboard") as demo:
     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")
-            # Create a hidden component for basin constant; always "All Basins"
             basin_constant = gr.Textbox(value="All Basins", visible=False)
         with gr.Row():
             typhoon_dropdown = gr.Dropdown(label="Tropical Cyclone")
@@ -996,15 +1347,16 @@ with gr.Blocks(title="Typhoon Analysis Dashboard") as demo:
         path_video = gr.Video(label="Tropical Cyclone Path Animation", format="mp4", interactive=False, elem_id="path_video")
         animation_info = gr.Markdown("""
         ### Animation Instructions
-        1. Select a year (data is from your processed CSV, using all basins).
+        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 free stock world map (centered at 180°) with a dynamic sidebar.
-           The sidebar shows the storm name and basin.
+        5. The animation displays the storm track on a world map with dynamic sidebar information.
         """)
-        # Update typhoon dropdown using only year (ignore basin since it's fixed)
-        year_dropdown.change(fn=update_typhoon_options_anim, inputs=[year_dropdown, gr.State("dummy")], outputs=typhoon_dropdown)
+        # 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)
@@ -1026,4 +1378,5 @@ with gr.Blocks(title="Typhoon Analysis Dashboard") as demo:
                                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])
 
-demo.launch(share=True)
+if __name__ == "__main__":
+    demo.launch(share=True)