Update app.py

app.py

@@ -1,7 +1,6 @@
 import gradio as gr
 import plotly.graph_objects as go
 import plotly.express as px
-from plotly.subplots import make_subplots
 import pickle
 import tropycal.tracks as tracks
 import pandas as pd
@@ -10,15 +9,19 @@ import cachetools
 import functools
 import hashlib
 import os
+import argparse
 from datetime import datetime, timedelta
-from datetime import date
+from datetime import date, datetime
 from scipy import stats
 from scipy.optimize import minimize, curve_fit
 from sklearn.linear_model import LinearRegression
 from sklearn.cluster import KMeans
 from scipy.interpolate import interp1d
 from fractions import Fraction
+from concurrent.futures import ThreadPoolExecutor
+from sklearn.metrics import mean_squared_error
 import statsmodels.api as sm
+import schedule
 import time
 import threading
 import requests
@@ -28,618 +31,707 @@ import csv
 from collections import defaultdict
 import shutil
 import filecmp
-import warnings
-warnings.filterwarnings('ignore')
 
-# Constants
-DATA_PATH = os.getcwd()
+# Add command-line argument parsing
+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()
+
+# Use the command-line argument for data path
+DATA_PATH = args.data_path
+
 ONI_DATA_PATH = os.path.join(DATA_PATH, 'oni_data.csv')
 TYPHOON_DATA_PATH = os.path.join(DATA_PATH, 'processed_typhoon_data.csv')
-LOCAL_iBtrace_PATH = os.path.join(DATA_PATH, 'ibtracs.WP.list.v04r00.csv')
-iBtrace_uri = 'https://www.ncei.noaa.gov/data/international-best-track-archive-for-climate-stewardship-ibtracs/v04r00/access/csv/ibtracs.WP.list.v04r00.csv'
+LOCAL_iBtrace_PATH =  os.path.join(DATA_PATH, 'ibtracs.WP.list.v04r01.csv')
+iBtrace_uri = 'https://www.ncei.noaa.gov/data/international-best-track-archive-for-climate-stewardship-ibtracs/v04r01/access/csv/ibtracs.WP.list.v04r01.csv'
+
 CACHE_FILE = 'ibtracs_cache.pkl'
 CACHE_EXPIRY_DAYS = 1
+last_oni_update = None
 
-# Color mappings
-COLOR_MAP = {
-    'C5 Super Typhoon': 'rgb(255, 0, 0)',
-    'C4 Very Strong Typhoon': 'rgb(255, 63, 0)', 
-    'C3 Strong Typhoon': 'rgb(255, 127, 0)',
-    'C2 Typhoon': 'rgb(255, 191, 0)',
-    'C1 Typhoon': 'rgb(255, 255, 0)',
-    'Tropical Storm': 'rgb(0, 255, 255)',
-    'Tropical Depression': 'rgb(173, 216, 230)'
+
+def should_update_oni():
+    today = datetime.now()
+    # Beginning of the month: 1st day
+    if today.day == 1:
+        return True
+    # Middle of the month: 15th day
+    if today.day == 15:
+        return True
+    # End of the month: last day
+    if today.day == (today.replace(day=1, month=today.month%12+1) - timedelta(days=1)).day:
+        return True
+    return False
+
+color_map = {
+    'C5 Super Typhoon': 'rgb(255, 0, 0)',      # Red
+    'C4 Very Strong Typhoon': 'rgb(255, 63, 0)', # Red-Orange
+    'C3 Strong Typhoon': 'rgb(255, 127, 0)',    # Orange
+    'C2 Typhoon': 'rgb(255, 191, 0)',          # Orange-Yellow
+    'C1 Typhoon': 'rgb(255, 255, 0)',          # Yellow
+    'Tropical Storm': 'rgb(0, 255, 255)',       # Cyan
+    'Tropical Depression': 'rgb(173, 216, 230)' # Light Blue
 }
 
-class TyphoonAnalyzer:
-    def __init__(self):
-        self.last_oni_update = None
-        self.ensure_data_files_exist()
-        self.load_initial_data()
+def convert_typhoondata(input_file, output_file):
+    with open(input_file, 'r') as infile:
+        # Skip the title and the unit line.
+        next(infile)
+        next(infile)
         
-    def ensure_data_files_exist(self):
-        """Ensure all required data files exist before loading"""
-        print("Checking and downloading required data files...")
+        reader = csv.reader(infile)
         
-        # Create data directory if it doesn't exist
-        os.makedirs(DATA_PATH, exist_ok=True)
+        # Used for storing data for each SID
+        sid_data = defaultdict(list)
         
-        # Download ONI data if it doesn't exist
-        if not os.path.exists(ONI_DATA_PATH):
-            print("Downloading ONI data...")
-            url = "https://www.cpc.ncep.noaa.gov/data/indices/oni.ascii.txt"
-            temp_file = os.path.join(DATA_PATH, "temp_oni.ascii.txt")
-            try:
-                response = requests.get(url)
-                response.raise_for_status()
-                with open(temp_file, 'wb') as f:
-                    f.write(response.content)
-                self.convert_oni_ascii_to_csv(temp_file, ONI_DATA_PATH)
-                print("ONI data downloaded and converted successfully")
-            except Exception as e:
-                print(f"Error downloading ONI data: {e}")
-                raise
-            finally:
-                if os.path.exists(temp_file):
-                    os.remove(temp_file)
-
-        # Download IBTrACS data if it doesn't exist
-        if not os.path.exists(LOCAL_iBtrace_PATH):
-            print("Downloading IBTrACS data...")
-            try:
-                response = requests.get(iBtrace_uri)
-                response.raise_for_status()
-                with open(LOCAL_iBtrace_PATH, 'w') as f:
-                    f.write(response.text)
-                print("IBTrACS data downloaded successfully")
-            except Exception as e:
-                print(f"Error downloading IBTrACS data: {e}")
-                raise
-
-        # Create processed typhoon data if it doesn't exist
-        if not os.path.exists(TYPHOON_DATA_PATH):
-            print("Processing typhoon data...")
-            try:
-                self.convert_typhoondata(LOCAL_iBtrace_PATH, TYPHOON_DATA_PATH)
-                print("Typhoon data processed successfully")
-            except Exception as e:
-                print(f"Error processing typhoon data: {e}")
-                raise
-
-        print("All required data files are ready")
-
-    def load_initial_data(self):
-        """Initialize all required data"""
-        print("Loading initial data...")
-        self.update_oni_data()
-        self.oni_df = self.fetch_oni_data_from_csv()
-        self.ibtracs = self.load_ibtracs_data()
-        self.update_typhoon_data()
-        self.oni_data, self.typhoon_data = self.load_data()
-        self.oni_long = self.process_oni_data(self.oni_data)
-        self.typhoon_max = self.process_typhoon_data(self.typhoon_data)
-        self.merged_data = self.merge_data()
-        print("Initial data loading complete")
-
-    def convert_typhoondata(self, input_file, output_file):
-        """Convert IBTrACS data to processed format"""
-        print(f"Converting typhoon data from {input_file} to {output_file}")
-        with open(input_file, 'r') as infile:
-            # Skip the header lines
-            next(infile)
-            next(infile)
-            
-            reader = csv.reader(infile)
-            sid_data = defaultdict(list)
-            
-            for row in reader:
-                if not row:  # Skip blank lines
-                    continue
-                
-                sid = row[0]
-                iso_time = row[6]
-                sid_data[sid].append((row, iso_time))
-
-        with open(output_file, 'w', newline='') as outfile:
-            fieldnames = ['SID', 'ISO_TIME', 'LAT', 'LON', 'SEASON', 'NAME', 
-                         'WMO_WIND', 'WMO_PRES', 'USA_WIND', 'USA_PRES', 
-                         'START_DATE', 'END_DATE']
-            writer = csv.DictWriter(outfile, fieldnames=fieldnames)
-            writer.writeheader()
+        for row in reader:
+            if not row:  # Skip the blank lines
+                continue
             
-            for sid, data in sid_data.items():
-                start_date = min(data, key=lambda x: x[1])[1]
-                end_date = max(data, key=lambda x: x[1])[1]
-                
-                for row, iso_time in data:
-                    writer.writerow({
-                        'SID': row[0],
-                        'ISO_TIME': iso_time,
-                        'LAT': row[8],
-                        'LON': row[9],
-                        'SEASON': row[1],
-                        'NAME': row[5],
-                        'WMO_WIND': row[10].strip() or ' ',
-                        'WMO_PRES': row[11].strip() or ' ',
-                        'USA_WIND': row[23].strip() or ' ',
-                        'USA_PRES': row[24].strip() or ' ',
-                        'START_DATE': start_date,
-                        'END_DATE': end_date
-                    })
-
-    def fetch_oni_data_from_csv(self):
-        """Load ONI data from CSV"""
-        df = pd.read_csv(ONI_DATA_PATH)
-        df = df.melt(id_vars=['Year'], var_name='Month', value_name='ONI')
-        
-        # Convert month numbers to month names
-        month_map = {
-            '01': 'Jan', '02': 'Feb', '03': 'Mar', '04': 'Apr',
-            '05': 'May', '06': 'Jun', '07': 'Jul', '08': 'Aug',
-            '09': 'Sep', '10': 'Oct', '11': 'Nov', '12': 'Dec'
-        }
-        df['Month'] = df['Month'].map(month_map)
-        
-        # Now create the date
-        df['Date'] = pd.to_datetime(df['Year'].astype(str) + df['Month'], format='%Y%b')
-        return df.set_index('Date')
+            sid = row[0]
+            iso_time = row[6]
+            sid_data[sid].append((row, iso_time))
 
-    def update_oni_data(self):
-        """Update ONI data from NOAA"""
-        if not self._should_update_oni():
-            return
+    with open(output_file, 'w', newline='') as outfile:
+        fieldnames = ['SID', 'ISO_TIME', 'LAT', 'LON', 'SEASON', 'NAME', 'WMO_WIND', 'WMO_PRES', 'USA_WIND', 'USA_PRES', 'START_DATE', 'END_DATE']
+        writer = csv.DictWriter(outfile, fieldnames=fieldnames)
         
-        url = "https://www.cpc.ncep.noaa.gov/data/indices/oni.ascii.txt"
-        with tempfile.NamedTemporaryFile(delete=False) as temp_file:
-            try:
-                response = requests.get(url)
-                response.raise_for_status()
-                temp_file.write(response.content)
-                self.convert_oni_ascii_to_csv(temp_file.name, ONI_DATA_PATH)
-                self.last_oni_update = date.today()
-            except Exception as e:
-                print(f"Error updating ONI data: {e}")
-            finally:
-                if os.path.exists(temp_file.name):
-                    os.remove(temp_file.name)
-
-    def _should_update_oni(self):
-        """Check if ONI data should be updated"""
-        today = datetime.now()
-        return (today.day in [1, 15] or 
-                today.day == (today.replace(day=1, month=today.month%12+1) - timedelta(days=1)).day)
-
-    def convert_oni_ascii_to_csv(self, input_file, output_file):
-        """Convert ONI ASCII data to CSV format"""
-        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
-        }
+        writer.writeheader()
         
+        for sid, data in sid_data.items():
+            start_date = min(data, key=lambda x: x[1])[1]
+            end_date = max(data, key=lambda x: x[1])[1]
+            
+            for row, iso_time in data:
+                writer.writerow({
+                    'SID': row[0],
+                    'ISO_TIME': iso_time,
+                    'LAT': row[8],
+                    'LON': row[9],
+                    'SEASON': row[1],
+                    'NAME': row[5],
+                    'WMO_WIND': row[10].strip() or ' ',  
+                    'WMO_PRES': row[11].strip() or ' ',
+                    'USA_WIND': row[23].strip() or ' ',
+                    'USA_PRES': row[24].strip() or ' ',
+                    'START_DATE': start_date,
+                    'END_DATE': end_date
+                })
+
+
+def download_oni_file(url, filename):
+    print(f"Downloading file from {url}...")
+    try:
+        response = requests.get(url)
+        response.raise_for_status()  # Raises an exception for non-200 status codes
+        with open(filename, 'wb') as f:
+            f.write(response.content)
+        print(f"File successfully downloaded and saved as {filename}")
+        return True
+    except requests.RequestException as e:
+        print(f"Download failed. Error: {e}")
+        return False
+
+
+def convert_oni_ascii_to_csv(input_file, output_file):
+    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
+    }
+    
+    print(f"Attempting to read file: {input_file}")
+    try:
         with open(input_file, 'r') as f:
-            next(f)  # Skip header
-            for line in f:
+            lines = f.readlines()
+            print(f"Successfully read {len(lines)} lines")
+            
+            if len(lines) <= 1:
+                print("Error: File is empty or contains only header")
+                return
+            
+            for line in lines[1:]:  # Skip header
                 parts = line.split()
                 if len(parts) >= 4:
-                    season, year, anom = parts[0], parts[1], parts[-1]
+                    season, year = parts[0], parts[1]
+                    anom = 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
+                    else:
+                        print(f"Warning: Unknown season: {season}")
+                else:
+                    print(f"Warning: Skipping invalid line: {line.strip()}")
+            
+            print(f"Processed data for {len(data)} years")
+    except Exception as e:
+        print(f"Error reading file: {e}")
+        return
 
+    print(f"Attempting to write file: {output_file}")
+    try:
         with open(output_file, 'w', newline='') as f:
             writer = csv.writer(f)
-            writer.writerow(['Year'] + [f"{m:02d}" for m in range(1, 13)])
+            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])
+                row = [year] + data[year]
+                writer.writerow(row)
+            
+            print(f"Successfully wrote {len(data)} rows of data")
+    except Exception as e:
+        print(f"Error writing file: {e}")
+        return
 
-    def load_ibtracs_data(self):
-        """Load IBTrACS data with caching"""
-        if os.path.exists(CACHE_FILE):
-            cache_time = datetime.fromtimestamp(os.path.getmtime(CACHE_FILE))
-            if datetime.now() - cache_time < timedelta(days=CACHE_EXPIRY_DAYS):
-                with open(CACHE_FILE, 'rb') as f:
-                    return pickle.load(f)
+    print(f"Conversion complete. Data saved to {output_file}")
 
-        if os.path.exists(LOCAL_iBtrace_PATH):
-            ibtracs = tracks.TrackDataset(basin='west_pacific', source='ibtracs', 
-                                         ibtracs_url=LOCAL_iBtrace_PATH)
+def update_oni_data():
+    global last_oni_update
+    current_date = date.today()
+    
+    # Check if already updated today
+    if last_oni_update == current_date:
+        print("ONI data already checked today. Skipping update.")
+        return
+    
+    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 filecmp.cmp(temp_file, input_file, shallow=False):
+            # File doesn't exist or has been updated
+            os.replace(temp_file, input_file)
+            print("New ONI data detected. Converting to CSV.")
+            convert_oni_ascii_to_csv(input_file, output_file)
+            print("ONI data updated successfully.")
         else:
+            print("ONI data is up to date. No conversion needed.")
+            os.remove(temp_file)  # Remove temporary file
+        
+        last_oni_update = current_date
+    else:
+        print("Failed to download ONI data.")
+        if os.path.exists(temp_file):
+            os.remove(temp_file)  # Ensure cleanup of temporary file
+
+def load_ibtracs_data():
+    if os.path.exists(CACHE_FILE):
+        cache_time = datetime.fromtimestamp(os.path.getmtime(CACHE_FILE))
+        if datetime.now() - cache_time < timedelta(days=CACHE_EXPIRY_DAYS):
+            print("Loading data from cache...")
+            with open(CACHE_FILE, 'rb') as f:
+                return pickle.load(f)
+    
+    if os.path.exists(LOCAL_iBtrace_PATH):
+        print("Using local IBTrACS file...")
+        ibtracs = tracks.TrackDataset(basin='west_pacific', source='ibtracs', ibtracs_url=LOCAL_iBtrace_PATH)
+    else:
+        print("Local IBTrACS file not found. Fetching data from remote server...")
+        try:
             response = requests.get(iBtrace_uri)
             response.raise_for_status()
-            with open(LOCAL_iBtrace_PATH, 'w') as f:
-                f.write(response.text)
-            ibtracs = tracks.TrackDataset(basin='west_pacific', source='ibtracs',
-                                         ibtracs_url=LOCAL_iBtrace_PATH)
+            
+            with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.csv') as temp_file:
+                temp_file.write(response.text)
+                temp_file_path = temp_file.name
+            
+            # Save the downloaded data as the local file
+            shutil.move(temp_file_path, LOCAL_iBtrace_PATH)
+            print(f"Downloaded data saved to {LOCAL_iBtrace_PATH}")
+            
+            ibtracs = tracks.TrackDataset(basin='west_pacific', source='ibtracs', ibtracs_url=LOCAL_iBtrace_PATH)
+        except requests.RequestException as e:
+            print(f"Error downloading data: {e}")
+            print("No local file available and download failed. Unable to load IBTrACS data.")
+            return None
+    
+    with open(CACHE_FILE, 'wb') as f:
+        pickle.dump(ibtracs, f)
+    
+    return ibtracs
+    
+def update_ibtracs_data():
+    global ibtracs
+    print("Checking for IBTrACS data updates...")
 
-        with open(CACHE_FILE, 'wb') as f:
-            pickle.dump(ibtracs, f)
-        return ibtracs
+    try:
+        # Get the last-modified time of the remote file
+        response = requests.head(iBtrace_uri)
+        remote_last_modified = datetime.strptime(response.headers['Last-Modified'], '%a, %d %b %Y %H:%M:%S GMT')
 
-    def update_typhoon_data(self):
-        """Update typhoon data from IBTrACS"""
-        try:
-            response = requests.head(iBtrace_uri)
-            remote_modified = datetime.strptime(response.headers['Last-Modified'], 
-                                               '%a, %d %b %Y %H:%M:%S GMT')
-            local_modified = (datetime.fromtimestamp(os.path.getmtime(LOCAL_iBtrace_PATH)) 
-                            if os.path.exists(LOCAL_iBtrace_PATH) else datetime.min)
-            
-            if remote_modified > local_modified:
-                response = requests.get(iBtrace_uri)
-                response.raise_for_status()
-                with open(LOCAL_iBtrace_PATH, 'w') as f:
-                    f.write(response.text)
-                print("Typhoon data updated successfully")
-        except Exception as e:
-            print(f"Error updating typhoon data: {e}")
-
-    def load_data(self):
-        """Load ONI and typhoon data"""
-        oni_data = pd.read_csv(ONI_DATA_PATH)
-        typhoon_data = pd.read_csv(TYPHOON_DATA_PATH, low_memory=False)
-        typhoon_data['ISO_TIME'] = pd.to_datetime(typhoon_data['ISO_TIME'])
-        return oni_data, typhoon_data
-
-    def process_oni_data(self, oni_data):
-        """Process ONI data"""
-        oni_long = oni_data.melt(id_vars=['Year'], var_name='Month', value_name='ONI')
+        # Get the last-modified time of the local file
+        if os.path.exists(LOCAL_iBtrace_PATH):
+            local_last_modified = datetime.fromtimestamp(os.path.getmtime(LOCAL_iBtrace_PATH))
+        else:
+            local_last_modified = datetime.min
+
+        # Compare the modification times
+        if remote_last_modified <= local_last_modified:
+            print("Local IBTrACS data is up to date. No update needed.")
+            if os.path.exists(CACHE_FILE):
+                # Update the cache file's timestamp to extend its validity
+                os.utime(CACHE_FILE, None)
+                print("Cache file timestamp updated.")
+            return
+
+        print("Remote data is newer. Updating IBTrACS data...")
         
-        # Create a mapping for month numbers
-        month_map = {
-            '01': 1, '02': 2, '03': 3, '04': 4,
-            '05': 5, '06': 6, '07': 7, '08': 8,
-            '09': 9, '10': 10, '11': 11, '12': 12
-        }
+        # Download the new data
+        response = requests.get(iBtrace_uri)
+        response.raise_for_status()
+        
+        with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.csv') as temp_file:
+            temp_file.write(response.text)
+            temp_file_path = temp_file.name
         
-        # Convert month strings to numbers directly
-        oni_long['Month'] = oni_long['Month'].map(month_map)
+        # Save the downloaded data as the local file
+        shutil.move(temp_file_path, LOCAL_iBtrace_PATH)
+        print(f"Downloaded data saved to {LOCAL_iBtrace_PATH}")
         
-        return oni_long
-
-    def process_typhoon_data(self, typhoon_data):
-        """Process typhoon data"""
-        typhoon_data['USA_WIND'] = pd.to_numeric(typhoon_data['USA_WIND'], errors='coerce')
-        typhoon_data['WMO_PRES'] = pd.to_numeric(typhoon_data['WMO_PRES'], errors='coerce')
-        typhoon_data['ISO_TIME'] = pd.to_datetime(typhoon_data['ISO_TIME'])
-        typhoon_data['Year'] = typhoon_data['ISO_TIME'].dt.year
-        typhoon_data['Month'] = typhoon_data['ISO_TIME'].dt.month
+        # Update the last modified time of the local file to match the remote file
+        os.utime(LOCAL_iBtrace_PATH, (remote_last_modified.timestamp(), remote_last_modified.timestamp()))
         
-        typhoon_max = typhoon_data.groupby(['SID', 'Year', 'Month']).agg({
-            'USA_WIND': 'max',
-            'WMO_PRES': 'min',
-            'NAME': 'first',
-            'LAT': 'first',
-            'LON': 'first',
-            'ISO_TIME': 'first'
-        }).reset_index()
+        ibtracs = tracks.TrackDataset(basin='west_pacific', source='ibtracs', ibtracs_url=LOCAL_iBtrace_PATH)
         
-        typhoon_max['Category'] = typhoon_max['USA_WIND'].apply(self.categorize_typhoon)
-        return typhoon_max
+        with open(CACHE_FILE, 'wb') as f:
+            pickle.dump(ibtracs, f)
+        print("IBTrACS data updated and cache refreshed.")
+
+    except requests.RequestException as e:
+        print(f"Error checking or downloading data: {e}")
+        if os.path.exists(LOCAL_iBtrace_PATH):
+            print("Using existing local file.")
+            ibtracs = tracks.TrackDataset(basin='west_pacific', source='ibtracs', ibtracs_url=LOCAL_iBtrace_PATH)
+            if os.path.exists(CACHE_FILE):
+                # Update the cache file's timestamp even when using existing local file
+                os.utime(CACHE_FILE, None)
+                print("Cache file timestamp updated.")
+        else:
+            print("No local file available. Update failed.")
+
+def run_schedule():
+    while True:
+        schedule.run_pending()
+        time.sleep(1)
+
+def analyze_typhoon_generation(merged_data, start_date, end_date):
+    filtered_data = merged_data[
+        (merged_data['ISO_TIME'] >= start_date) & 
+        (merged_data['ISO_TIME'] <= end_date)
+    ]
+    
+    filtered_data['ENSO_Phase'] = filtered_data['ONI'].apply(classify_enso_phases)
+    
+    typhoon_counts = filtered_data['ENSO_Phase'].value_counts().to_dict()
+    
+    month_counts = filtered_data.groupby(['ENSO_Phase', filtered_data['ISO_TIME'].dt.month]).size().unstack(fill_value=0)
+    concentrated_months = month_counts.idxmax(axis=1).to_dict()
+    
+    return typhoon_counts, concentrated_months
+
+def cache_key_generator(*args, **kwargs):
+    key = hashlib.md5()
+    for arg in args:
+        key.update(str(arg).encode())
+    for k, v in sorted(kwargs.items()):
+        key.update(str(k).encode())
+        key.update(str(v).encode())
+    return key.hexdigest()
+
+def categorize_typhoon(wind_speed):
+    wind_speed_kt = wind_speed / 2  # Convert kt to m/s
+    
+    # Add category classification
+    if wind_speed_kt >= 137/2.35:
+        return 'C5 Super Typhoon'
+    elif wind_speed_kt >= 113/2.35:
+        return 'C4 Very Strong Typhoon' 
+    elif wind_speed_kt >= 96/2.35:
+        return 'C3 Strong Typhoon'
+    elif wind_speed_kt >= 83/2.35:
+        return 'C2 Typhoon'
+    elif wind_speed_kt >= 64/2.35:
+        return 'C1 Typhoon'
+    elif wind_speed_kt >= 34/2.35:
+        return 'Tropical Storm'
+    else:
+        return 'Tropical Depression'
+
+@functools.lru_cache(maxsize=None)
+def process_oni_data_cached(oni_data_hash):
+    return process_oni_data(oni_data)
+
+def process_oni_data(oni_data):
+    oni_long = oni_data.melt(id_vars=['Year'], var_name='Month', value_name='ONI')
+    oni_long['Month'] = oni_long['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'
+    })
+    oni_long['Date'] = pd.to_datetime(oni_long['Year'].astype(str) + '-' + oni_long['Month'] + '-01')
+    oni_long['ONI'] = pd.to_numeric(oni_long['ONI'], errors='coerce')
+    return oni_long
+
+def process_oni_data_with_cache(oni_data):
+    oni_data_hash = cache_key_generator(oni_data.to_json())
+    return process_oni_data_cached(oni_data_hash)
+
+@functools.lru_cache(maxsize=None)
+def process_typhoon_data_cached(typhoon_data_hash):
+    return process_typhoon_data(typhoon_data)
+
+def process_typhoon_data(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')
+    
+    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 process_typhoon_data_with_cache(typhoon_data):
+    typhoon_data_hash = cache_key_generator(typhoon_data.to_json())
+    return process_typhoon_data_cached(typhoon_data_hash)
+
+def merge_data(oni_long, typhoon_max):
+    return pd.merge(typhoon_max, oni_long, on=['Year', 'Month'])
+
+def calculate_logistic_regression(merged_data):
+    data = merged_data.dropna(subset=['USA_WIND', 'ONI'])
+    
+    # Create binary outcome for severe typhoons
+    data['severe_typhoon'] = (data['USA_WIND'] >= 51).astype(int)
+    
+    # Create binary predictor for El Niño
+    data['el_nino'] = (data['ONI'] >= 0.5).astype(int)
+    
+    X = data['el_nino']
+    X = sm.add_constant(X)  # Add constant term
+    y = data['severe_typhoon']
+    
+    model = sm.Logit(y, X).fit()
+    
+    beta_1 = model.params['el_nino']
+    exp_beta_1 = np.exp(beta_1)
+    p_value = model.pvalues['el_nino']
+    
+    return beta_1, exp_beta_1, p_value
+
+@cachetools.cached(cache={})
+def fetch_oni_data_from_csv(file_path):
+    df = pd.read_csv(file_path, sep=',', header=0, na_values='-99.90')
+    df.columns = ['Year', 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
+    df = df.melt(id_vars=['Year'], var_name='Month', value_name='ONI')
+    df['Date'] = pd.to_datetime(df['Year'].astype(str) + df['Month'], format='%Y%b')
+    df = df.set_index('Date')
+    return df
+
+def classify_enso_phases(oni_value):
+    if isinstance(oni_value, pd.Series):
+        oni_value = oni_value.iloc[0]
+    if oni_value >= 0.5:
+        return 'El Nino'
+    elif oni_value <= -0.5:
+        return 'La Nina'
+    else:
+        return 'Neutral'
 
-    def merge_data(self):
-        """Merge ONI and typhoon data"""
-        return pd.merge(self.typhoon_max, self.oni_long, on=['Year', 'Month'])
+def load_data(oni_data_path, typhoon_data_path):
+    oni_data = pd.read_csv(oni_data_path)
+    typhoon_data = pd.read_csv(typhoon_data_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'])
+    
+    print(f"Typhoon data shape after cleaning: {typhoon_data.shape}")
+    print(f"Year range: {typhoon_data['ISO_TIME'].dt.year.min()} - {typhoon_data['ISO_TIME'].dt.year.max()}")
+    
+    return oni_data, typhoon_data
 
-    def categorize_typhoon(self, wind_speed):
-        """Categorize typhoon based on wind speed"""
-        if np.isnan(wind_speed):
-            return 'Unknown'
+def preprocess_data(oni_data, typhoon_data):
+    typhoon_data['USA_WIND'] = pd.to_numeric(typhoon_data['USA_WIND'], errors='coerce')
+    typhoon_data['WMO_PRES'] = pd.to_numeric(typhoon_data['WMO_PRES'], errors='coerce')
+    typhoon_data['ISO_TIME'] = pd.to_datetime(typhoon_data['ISO_TIME'], errors='coerce')
+    typhoon_data['Year'] = typhoon_data['ISO_TIME'].dt.year
+    typhoon_data['Month'] = typhoon_data['ISO_TIME'].dt.month
+    
+    monthly_max_wind_speed = typhoon_data.groupby(['Year', 'Month'])['USA_WIND'].max().reset_index()
+    
+    oni_data_long = pd.melt(oni_data, id_vars=['Year'], var_name='Month', value_name='ONI')
+    oni_data_long['Month'] = oni_data_long['Month'].apply(lambda x: pd.to_datetime(x, format='%b').month)
+    
+    merged_data = pd.merge(monthly_max_wind_speed, oni_data_long, on=['Year', 'Month'])
+    
+    return merged_data
+
+def calculate_max_wind_min_pressure(typhoon_data):
+    max_wind_speed = typhoon_data['USA_WIND'].max()
+    min_pressure = typhoon_data['WMO_PRES'].min()
+    return max_wind_speed, min_pressure
+
+@functools.lru_cache(maxsize=None)
+def get_storm_data(storm_id):
+    return ibtracs.get_storm(storm_id)
+
+def filter_west_pacific_coordinates(lons, lats):
+    mask = (100 <= lons) & (lons <= 180) & (0 <= lats) & (lats <= 40)
+    return lons[mask], lats[mask]
+
+def polynomial_exp(x, a, b, c, d):
+    return a * x**2 + b * x + c + d * np.exp(x)
+
+def exponential(x, a, b, c):
+    return a * np.exp(b * x) + c
+
+def generate_cluster_equations(cluster_center):
+    X = cluster_center[:, 0]  # Longitudes
+    y = cluster_center[:, 1]  # Latitudes
+    
+    x_min = X.min()
+    x_max = X.max()
+    
+    equations = []
+
+    # Fourier Series (up to 4th order)
+    def fourier_series(x, a0, a1, b1, a2, b2, a3, b3, a4, b4):
+        return (a0 + a1*np.cos(x) + b1*np.sin(x) + 
+                a2*np.cos(2*x) + b2*np.sin(2*x) + 
+                a3*np.cos(3*x) + b3*np.sin(3*x) + 
+                a4*np.cos(4*x) + b4*np.sin(4*x))
+
+    # Normalize X to the range [0, 2π]
+    X_normalized = 2 * np.pi * (X - x_min) / (x_max - x_min)
+
+    params, _ = curve_fit(fourier_series, X_normalized, y)
+    a0, a1, b1, a2, b2, a3, b3, a4, b4 = params
+    
+    # Create the equation string
+    fourier_eq = (f"y = {a0:.4f} + {a1:.4f}*cos(x) + {b1:.4f}*sin(x) + "
+                  f"{a2:.4f}*cos(2x) + {b2:.4f}*sin(2x) + "
+                  f"{a3:.4f}*cos(3x) + {b3:.4f}*sin(3x) + "
+                  f"{a4:.4f}*cos(4x) + {b4:.4f}*sin(4x)")
+    
+    equations.append(("Fourier Series", fourier_eq))
+    equations.append(("X Range", f"x goes from 0 to {2*np.pi:.4f}"))
+    equations.append(("Longitude Range", f"Longitude goes from {x_min:.4f}°E to {x_max:.4f}°E"))
+
+    return equations, (x_min, x_max)
+    
+
+
+
+# Classification standards
+atlantic_standard = {
+    'C5 Super Typhoon': {'wind_speed': 137, 'color': 'rgb(255, 0, 0)'},      
+    'C4 Very Strong Typhoon': {'wind_speed': 113, 'color': 'rgb(255, 63, 0)'}, 
+    'C3 Strong Typhoon': {'wind_speed': 96, 'color': 'rgb(255, 127, 0)'},    
+    'C2 Typhoon': {'wind_speed': 83, 'color': 'rgb(255, 191, 0)'},          
+    'C1 Typhoon': {'wind_speed': 64, 'color': 'rgb(255, 255, 0)'},          
+    'Tropical Storm': {'wind_speed': 34, 'color': 'rgb(0, 255, 255)'},       
+    'Tropical Depression': {'wind_speed': 0, 'color': 'rgb(173, 216, 230)'}  
+}
+
+taiwan_standard = {
+    'Strong Typhoon': {'wind_speed': 51.0, 'color': 'rgb(255, 0, 0)'},       # >= 51.0 m/s
+    'Medium Typhoon': {'wind_speed': 33.7, 'color': 'rgb(255, 127, 0)'},     # 33.7-50.9 m/s
+    'Mild Typhoon': {'wind_speed': 17.2, 'color': 'rgb(255, 255, 0)'},       # 17.2-33.6 m/s
+    'Tropical Depression': {'wind_speed': 0, 'color': 'rgb(173, 216, 230)'}  # < 17.2 m/s
+}
+
+def categorize_typhoon_by_standard(wind_speed, standard='atlantic'):
+    """
+    Categorize typhoon based on wind speed and chosen standard
+    wind_speed is in knots
+    """
+    if standard == 'taiwan':
+        # Convert knots to m/s for Taiwan standard
+        wind_speed_ms = wind_speed * 0.514444
+        
+        if wind_speed_ms >= 51.0:
+            return 'Strong Typhoon', taiwan_standard['Strong Typhoon']['color']
+        elif wind_speed_ms >= 33.7:
+            return 'Medium Typhoon', taiwan_standard['Medium Typhoon']['color']
+        elif wind_speed_ms >= 17.2:
+            return 'Mild Typhoon', taiwan_standard['Mild Typhoon']['color']
+        else:
+            return 'Tropical Depression', taiwan_standard['Tropical Depression']['color']
+    else:
+        # Atlantic standard uses knots
         if wind_speed >= 137:
-            return 'C5 Super Typhoon'
+            return 'C5 Super Typhoon', atlantic_standard['C5 Super Typhoon']['color']
         elif wind_speed >= 113:
-            return 'C4 Very Strong Typhoon'
+            return 'C4 Very Strong Typhoon', atlantic_standard['C4 Very Strong Typhoon']['color']
         elif wind_speed >= 96:
-            return 'C3 Strong Typhoon'
+            return 'C3 Strong Typhoon', atlantic_standard['C3 Strong Typhoon']['color']
         elif wind_speed >= 83:
-            return 'C2 Typhoon'
+            return 'C2 Typhoon', atlantic_standard['C2 Typhoon']['color']
         elif wind_speed >= 64:
-            return 'C1 Typhoon'
+            return 'C1 Typhoon', atlantic_standard['C1 Typhoon']['color']
         elif wind_speed >= 34:
-            return 'Tropical Storm'
+            return 'Tropical Storm', atlantic_standard['Tropical Storm']['color']
         else:
-            return 'Tropical Depression'
+            return 'Tropical Depression', atlantic_standard['Tropical Depression']['color']
 
-    def analyze_typhoon(self, start_year, start_month, end_year, end_month, enso_value='all'):
-        """Main analysis function"""
-        start_date = datetime(start_year, start_month, 1)
-        end_date = datetime(end_year, end_month, 28)
-        
-        filtered_data = self.merged_data[
-            (self.merged_data['ISO_TIME'] >= start_date) & 
-            (self.merged_data['ISO_TIME'] <= end_date)
-        ]
+# Initialize data at startup
+def initialize_data():
+    global oni_df, ibtracs, oni_data, typhoon_data, oni_long, typhoon_max, merged_data, data, max_wind_speed, min_pressure
+    
+    print(f"Using data path: {DATA_PATH}")
+    # Update ONI data before starting the application
+    update_oni_data()
+    oni_df = fetch_oni_data_from_csv(ONI_DATA_PATH)
+    ibtracs = load_ibtracs_data()
+    
+    if os.path.exists(LOCAL_iBtrace_PATH):
+        convert_typhoondata(LOCAL_iBtrace_PATH, TYPHOON_DATA_PATH)
+    
+    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)
+    data = preprocess_data(oni_data, typhoon_data)
+    max_wind_speed, min_pressure = calculate_max_wind_min_pressure(typhoon_data)
+    
+    # Schedule data updates
+    schedule.every().day.at("01:00").do(update_ibtracs_data)
+    schedule.every().day.at("00:00").do(lambda: update_oni_data() if should_update_oni() else None)
+    
+    # Run the scheduler in a separate thread
+    scheduler_thread = threading.Thread(target=run_schedule)
+    scheduler_thread.daemon = True
+    scheduler_thread.start()
+    
+    return oni_df, ibtracs, typhoon_data
+
+# Function to get available years from typhoon data
+def get_available_years():
+    if typhoon_data is None:
+        return []
+    years = typhoon_data['ISO_TIME'].dt.year.unique()
+    years = years[~np.isnan(years)]
+    years = sorted(years)
+    return years
+
+# Function to get available typhoons for a selected year
+def get_typhoons_for_year(year):
+    if not year or ibtracs is None:
+        return []
+    
+    try:
+        year = int(year)
+        season = ibtracs.get_season(year)
+        storm_summary = season.summary()
         
-        if enso_value != 'all':
-            filtered_data = filtered_data[
-                (filtered_data['ONI'] >= 0.5 if enso_value == 'el_nino' else
-                 filtered_data['ONI'] <= -0.5 if enso_value == 'la_nina' else
-                 (filtered_data['ONI'] > -0.5) & (filtered_data['ONI'] < 0.5))
-            ]
+        typhoon_options = []
+        for i in range(storm_summary['season_storms']):
+            storm_id = storm_summary['id'][i]
+            storm_name = storm_summary['name'][i]
+            typhoon_options.append((f"{storm_name} ({storm_id})", storm_id))
         
-        return {
-            'tracks': self.create_tracks_plot(filtered_data),
-            'wind': self.create_wind_analysis(filtered_data),
-            'pressure': self.create_pressure_analysis(filtered_data),
-            'stats': self.generate_statistics(filtered_data)
-        }
+        return typhoon_options
+    except Exception as e:
+        print(f"Error getting typhoons for year {year}: {e}")
+        return []
 
-    def create_tracks_plot(self, data):
-        """Create typhoon tracks visualization"""
+# Create animation for typhoon path
+def create_typhoon_path_animation(year, typhoon_id, standard):
+    if not year or not typhoon_id:
+        return None
+    
+    try:
+        storm = ibtracs.get_storm(typhoon_id)
         fig = go.Figure()
-        
-        fig.update_layout(
-            title={
-                'text': 'Typhoon Tracks',
-                'y':0.95,
-                'x':0.5,
-                'xanchor': 'center',
-                'yanchor': 'top'
-            },
-            showlegend=True,
-            legend=dict(
-                yanchor="top",
-                y=0.99,
-                xanchor="left",
-                x=0.01,
-                bgcolor='rgba(255, 255, 255, 0.8)'
-            ),
-            geo=dict(
-                projection_type='mercator',
-                showland=True,
-                showcoastlines=True,
-                landcolor='rgb(243, 243, 243)',
-                countrycolor='rgb(204, 204, 204)',
-                coastlinecolor='rgb(214, 214, 214)',
-                showocean=True,
-                oceancolor='rgb(230, 250, 255)',
-                showlakes=True,
-                lakecolor='rgb(230, 250, 255)',
-                lataxis=dict(range=[0, 50]),
-                lonaxis=dict(range=[100, 180]),
-                center=dict(lat=20, lon=140),
-                bgcolor='rgba(255, 255, 255, 0.5)'
-            ),
-            paper_bgcolor='rgba(255, 255, 255, 0.5)',
-            plot_bgcolor='rgba(255, 255, 255, 0.5)'
-        )
-
-        for category in COLOR_MAP.keys():
-            category_data = data[data['Category'] == category]
-            for _, storm in category_data.groupby('SID'):
-                track_data = self.typhoon_data[self.typhoon_data['SID'] == storm['SID'].iloc[0]]
-                track_data = track_data.sort_values('ISO_TIME')
-                
-                fig.add_trace(go.Scattergeo(
-                    lon=track_data['LON'],
-                    lat=track_data['LAT'],
-                    mode='lines',
-                    line=dict(
-                        width=2,
-                        color=COLOR_MAP[category]
-                    ),
-                    name=category,
-                    legendgroup=category,
-                    showlegend=True if storm.iloc[0]['SID'] == category_data.iloc[0]['SID'] else False,
-                    hovertemplate=(
-                        f"Name: {storm['NAME'].iloc[0]}<br>" +
-                        f"Category: {category}<br>" +
-                        f"Wind Speed: {storm['USA_WIND'].iloc[0]:.1f} kt<br>" +
-                        f"Pressure: {storm['WMO_PRES'].iloc[0]:.1f} hPa<br>" +
-                        f"Date: {track_data['ISO_TIME'].dt.strftime('%Y-%m-%d %H:%M').iloc[0]}<br>" +
-                        f"Lat: {track_data['LAT'].iloc[0]:.2f}°N<br>" +
-                        f"Lon: {track_data['LON'].iloc[0]:.2f}°E<br>" +
-                        "<extra></extra>"
-                    )
-                ))
 
-        return fig
-
-    def create_wind_analysis(self, data):
-        """Create wind speed analysis plot"""
-        fig = px.scatter(data,
-            x='ONI',
-            y='USA_WIND',
-            color='Category',
-            color_discrete_map=COLOR_MAP,
-            title='Wind Speed vs ONI Index',
-            labels={
-                'ONI': 'Oceanic Niño Index',
-                'USA_WIND': 'Maximum Wind Speed (kt)'
-            },
-            hover_data=['NAME', 'ISO_TIME', 'Category']
-        )
-        
-        # Add regression line
-        x = data['ONI']
-        y = data['USA_WIND']
-        slope, intercept = np.polyfit(x, y, 1)
         fig.add_trace(
-            go.Scatter(
-                x=x,
-                y=slope * x + intercept,
+            go.Scattergeo(
+                lon=storm.lon,
+                lat=storm.lat,
                 mode='lines',
-                name=f'Regression (slope={slope:.2f})',
-                line=dict(color='black', dash='dash')
+                line=dict(width=2, color='gray'),
+                name='Path',
+                showlegend=False,
             )
         )
-        
-        return fig
 
-    def create_pressure_analysis(self, data):
-        """Create pressure analysis plot"""
-        fig = px.scatter(data,
-            x='ONI',
-            y='WMO_PRES',
-            color='Category',
-            color_discrete_map=COLOR_MAP,
-            title='Pressure vs ONI Index',
-            labels={
-                'ONI': 'Oceanic Niño Index',
-                'WMO_PRES': 'Minimum Pressure (hPa)'
-            },
-            hover_data=['NAME', 'ISO_TIME', 'Category']
-        )
-        
-        # Add regression line
-        x = data['ONI']
-        y = data['WMO_PRES']
-        slope, intercept = np.polyfit(x, y, 1)
         fig.add_trace(
-            go.Scatter(
-                x=x,
-                y=slope * x + intercept,
-                mode='lines',
-                name=f'Regression (slope={slope:.2f})',
-                line=dict(color='black', dash='dash')
-            )
-        )
-        
-        return fig
-
-    def generate_statistics(self, data):
-        """Generate statistical summary"""
-        stats = {
-            'total_typhoons': len(data['SID'].unique()),
-            'avg_wind': data['USA_WIND'].mean(),
-            'max_wind': data['USA_WIND'].max(),
-            'avg_pressure': data['WMO_PRES'].mean(),
-            'min_pressure': data['WMO_PRES'].min(),
-            'oni_correlation_wind': data['ONI'].corr(data['USA_WIND']),
-            'oni_correlation_pressure': data['ONI'].corr(data['WMO_PRES']),
-            'category_counts': data['Category'].value_counts().to_dict()
-        }
-        
-        return f"""
-### Statistical Summary
-
-- Total Typhoons: {stats['total_typhoons']}
-- Average Wind Speed: {stats['avg_wind']:.2f} kt
-- Maximum Wind Speed: {stats['max_wind']:.2f} kt
-- Average Pressure: {stats['avg_pressure']:.2f} hPa
-- Minimum Pressure: {stats['min_pressure']:.2f} hPa
-- ONI-Wind Speed Correlation: {stats['oni_correlation_wind']:.3f}
-- ONI-Pressure Correlation: {stats['oni_correlation_pressure']:.3f}
-
-### Category Distribution
-{chr(10).join(f'- {cat}: {count}' for cat, count in stats['category_counts'].items())}
-"""
-
-    def analyze_clusters(self, year, n_clusters):
-        """Analyze typhoon clusters for a specific year"""
-        year_data = self.typhoon_data[self.typhoon_data['SEASON'] == year]
-        if year_data.empty:
-            return go.Figure(), "No data available for selected year"
-
-        # Prepare data for clustering
-        routes = []
-        for _, storm in year_data.groupby('SID'):
-            if len(storm) > 1:
-                # Standardize route length
-                t = np.linspace(0, 1, len(storm))
-                t_new = np.linspace(0, 1, 100)
-                lon_interp = interp1d(t, storm['LON'], kind='linear')(t_new)
-                lat_interp = interp1d(t, storm['LAT'], kind='linear')(t_new)
-                routes.append(np.column_stack((lon_interp, lat_interp)))
-        
-        if len(routes) < n_clusters:
-            return go.Figure(), f"Not enough typhoons ({len(routes)}) for {n_clusters} clusters"
-
-        # Perform clustering
-        routes_array = np.array(routes)
-        routes_reshaped = routes_array.reshape(routes_array.shape[0], -1)
-        kmeans = KMeans(n_clusters=n_clusters, random_state=42)
-        clusters = kmeans.fit_predict(routes_reshaped)
-        
-        # Create visualization
-        fig = go.Figure()
-        
-        # Set layout
-        fig.update_layout(
-            title=f'Typhoon Route Clusters ({year})',
-            showlegend=True,
-            geo=dict(
-                projection_type='mercator',
-                showland=True,
-                showcoastlines=True,
-                landcolor='rgb(243, 243, 243)',
-                countrycolor='rgb(204, 204, 204)',
-                coastlinecolor='rgb(214, 214, 214)',
-                showocean=True,
-                oceancolor='rgb(230, 250, 255)',
-                lataxis=dict(range=[0, 50]),
-                lonaxis=dict(range=[100, 180]),
-                center=dict(lat=20, lon=140)
+            go.Scattergeo(
+                lon=[storm.lon[0]],
+                lat=[storm.lat[0]],
+                mode='markers',
+                marker=dict(size=10, color='green', symbol='star'),
+                name='Starting Point',
+                text=storm.time[0].strftime('%Y-%m-%d %H:%M'),
+                hoverinfo='text+name',
             )
         )
-        
-        # Plot routes colored by cluster
-        for route, cluster_id in zip(routes, clusters):
-            fig.add_trace(go.Scattergeo(
-                lon=route[:, 0],
-                lat=route[:, 1],
-                mode='lines',
-                line=dict(
-                    width=1, 
-                    color=f'hsl({cluster_id * 360/n_clusters}, 50%, 50%)'
-                ),
-                name=f'Cluster {cluster_id + 1}',
-                showlegend=False
-            ))
-        
-        # Plot cluster centers
-        for i in range(n_clusters):
-            center = kmeans.cluster_centers_[i].reshape(-1, 2)
-            fig.add_trace(go.Scattergeo(
-                lon=center[:, 0],
-                lat=center[:, 1],
-                mode='lines',
-                name=f'Cluster {i+1} Center',
-                line=dict(
-                    width=3,
-                    color=f'hsl({i * 360/n_clusters}, 100%, 50%)'
-                )
-            ))
-        
-        # Generate statistics text
-        stats_text = "### Clustering Results\n\n"
-        cluster_counts = np.bincount(clusters)
-        for i in range(n_clusters):
-            stats_text += f"- Cluster {i+1}: {cluster_counts[i]} typhoons\n"
-        
-        return fig, stats_text
 
-    def get_typhoons_for_year(self, year):
-        """Get list of typhoons for a specific year"""
-        try:
-            season = self.ibtracs.get_season(year)
-            storm_summary = season.summary()
-            
-            typhoon_options = []
-            for i in range(storm_summary['season_storms']):
-                storm_id = storm_summary['id'][i]
-                storm_name = storm_summary['name'][i]
-                typhoon_options.append({'label': f"{storm_name} ({storm_id})", 'value': storm_id})
+        frames = []
+        for i in range(len(storm.time)):
+            category, color = categorize_typhoon_by_standard(storm.vmax[i], standard)
             
-            return typhoon_options
-        except Exception as e:
-            print(f"Error getting typhoons for year {year}: {str(e)}")
-            return []
-
-    def create_typhoon_animation(self, year, storm_id, standard='atlantic'):
-        """Create animated visualization of typhoon path"""
-        if not storm_id:
-            return go.Figure(), "Please select a typhoon"
+            # Get additional data if available
+            r34_ne = storm.dict['USA_R34_NE'][i] if 'USA_R34_NE' in storm.dict else None
+            r34_se = storm.dict['USA_R34_SE'][i] if 'USA_R34_SE' in storm.dict else None
+            r34_sw = storm.dict['USA_R34_SW'][i] if 'USA_R34_SW' in storm.dict else None
+            r34_nw = storm.dict['USA_R34_NW'][i] if 'USA_R34_NW' in storm.dict else None
+            rmw = storm.dict['USA_RMW'][i] if 'USA_RMW' in storm.dict else None
+            eye_diameter = storm.dict['USA_EYE'][i] if 'USA_EYE' in storm.dict else None
+
+            radius_info = f"R34: NE={r34_ne}, SE={r34_se}, SW={r34_sw}, NW={r34_nw}<br>"
+            radius_info += f"RMW: {rmw}<br>"
+            radius_info += f"Eye Diameter: {eye_diameter}"
             
-        storm = self.ibtracs.get_storm(storm_id)
-        
-        fig = go.Figure()
+            frame_data = [
+                go.Scattergeo(
+                    lon=storm.lon[:i+1],
+                    lat=storm.lat[:i+1],
+                    mode='lines',
+                    line=dict(width=2, color='blue'),
+                    name='Path Traveled',
+                    showlegend=False,
+                ),
+                go.Scattergeo(
+                    lon=[storm.lon[i]],
+                    lat=[storm.lat[i]],
+                    mode='markers+text',
+                    marker=dict(size=10, color=color, symbol='star'),
+                    text=category,
+                    textposition="top center",
+                    textfont=dict(size=12, color=color),
+                    name='Current Location',
+                    hovertext=f"{storm.time[i].strftime('%Y-%m-%d %H:%M')}<br>"
+                              f"Category: {category}<br>"
+                              f"Wind Speed: {storm.vmax[i]:.1f} m/s<br>"
+                              f"{radius_info}",
+                    hoverinfo='text',
+                ),
+            ]
+            frames.append(go.Frame(data=frame_data, name=f"frame{i}"))
+
+        fig.frames = frames
 
-        # Base map setup with correct scaling
         fig.update_layout(
-            title=f"{year} - {storm.name} Typhoon Path",
+            title=f"{year} Year {storm.name} Typhoon Path",
+            showlegend=False,
             geo=dict(
                 projection_type='natural earth',
                 showland=True,
@@ -648,9 +740,6 @@ class TyphoonAnalyzer:
                 coastlinecolor='rgb(100, 100, 100)',
                 showocean=True,
                 oceancolor='rgb(230, 250, 255)',
-                lataxis=dict(range=[0, 50]),
-                lonaxis=dict(range=[100, 180]),
-                center=dict(lat=20, lon=140),
             ),
             updatemenus=[{
                 "buttons": [
@@ -677,375 +766,561 @@ class TyphoonAnalyzer:
                 "xanchor": "right",
                 "y": 0,
                 "yanchor": "top"
+            }],
+            sliders=[{
+                "active": 0,
+                "yanchor": "top",
+                "xanchor": "left",
+                "currentvalue": {
+                    "font": {"size": 20},
+                    "prefix": "Time: ",
+                    "visible": True,
+                    "xanchor": "right"
+                },
+                "transition": {"duration": 100, "easing": "cubic-in-out"},
+                "pad": {"b": 10, "t": 50},
+                "len": 0.9,
+                "x": 0.1,
+                "y": 0,
+                "steps": [
+                    {
+                        "args": [[f"frame{k}"],
+                                {"frame": {"duration": 100, "redraw": True},
+                                  "mode": "immediate",
+                                  "transition": {"duration": 0}}
+                                ],
+                        "label": storm.time[k].strftime('%Y-%m-%d %H:%M'),
+                        "method": "animate"
+                    }
+                    for k in range(len(storm.time))
+                ]
             }]
         )
 
-        # Create animation frames
-        frames = []
-        for i in range(len(storm.time)):
-            category, color = self.categorize_typhoon_by_standard(storm.vmax[i], standard)
+        return fig
+    except Exception as e:
+        print(f"Error creating typhoon path animation: {e}")
+        return None
+
+# Function to analyze typhoon tracks 
+def analyze_typhoon_tracks(start_year, start_month, end_year, end_month, enso_selection, typhoon_search=""):
+    start_date = datetime(int(start_year), int(start_month), 1)
+    end_date = datetime(int(end_year), int(end_month), 28)
+    
+    # Create typhoon tracks plot
+    fig_tracks = go.Figure()
+    
+    # Map Gradio dropdown values to the values used in the original code
+    enso_map = {
+        "All Years": "all", 
+        "El Niño Years": "el_nino", 
+        "La Niña Years": "la_nina", 
+        "Neutral Years": "neutral"
+    }
+    enso_value = enso_map[enso_selection]
+    
+    try:
+        for year in range(int(start_year), int(end_year) + 1):
+            if year not in ibtracs.data.keys():
+                continue
             
-            # Get extra radius data if available
-            radius_info = ""
-            if hasattr(storm, 'dict'):
-                r34_ne = storm.dict.get('USA_R34_NE', [None])[i] if 'USA_R34_NE' in storm.dict else None
-                r34_se = storm.dict.get('USA_R34_SE', [None])[i] if 'USA_R34_SE' in storm.dict else None
-                r34_sw = storm.dict.get('USA_R34_SW', [None])[i] if 'USA_R34_SW' in storm.dict else None
-                r34_nw = storm.dict.get('USA_R34_NW', [None])[i] if 'USA_R34_NW' in storm.dict else None
-                rmw = storm.dict.get('USA_RMW', [None])[i] if 'USA_RMW' in storm.dict else None
-                eye = storm.dict.get('USA_EYE', [None])[i] if 'USA_EYE' in storm.dict else None
+            season = ibtracs.get_season(year)
+            for storm_id in season.summary()['id']:
+                storm = get_storm_data(storm_id)
+                storm_dates = storm.time
                 
-                if any([r34_ne, r34_se, r34_sw, r34_nw, rmw, eye]):
-                    radius_info = f"<br>R34: NE={r34_ne}, SE={r34_se}, SW={r34_sw}, NW={r34_nw}<br>"
-                    radius_info += f"RMW: {rmw}<br>Eye Diameter: {eye}"
-            
-            frame = go.Frame(
-                data=[
-                    go.Scattergeo(
-                        lon=storm.lon[:i+1],
-                        lat=storm.lat[:i+1],
-                        mode='lines',
-                        line=dict(width=2, color='blue'),
-                        name='Path Traveled',
-                        showlegend=False,
-                    ),
-                    go.Scattergeo(
-                        lon=[storm.lon[i]],
-                        lat=[storm.lat[i]],
-                        mode='markers+text',
-                        marker=dict(size=10, color=color, symbol='star'),
-                        text=category,
-                        textposition="top center",
-                        textfont=dict(size=12, color=color),
-                        name='Current Location',
-                        hovertemplate=(
-                            f"{storm.time[i].strftime('%Y-%m-%d %H:%M')}<br>"
-                            f"Category: {category}<br>"
-                            f"Wind Speed: {storm.vmax[i]:.1f} kt<br>"
-                            f"{radius_info}"
-                        ),
-                    ),
-                ],name=f"frame{i}"
-            )
-            frames.append(frame)
-
-        fig.frames = frames
+                if any(start_date <= date <= end_date for date in storm_dates):
+                    storm_date_str = storm_dates[0].strftime('%Y-%b')
+                    if storm_date_str in oni_df.index:
+                        storm_oni = oni_df.loc[storm_date_str]['ONI']
+                        if isinstance(storm_oni, pd.Series):
+                            storm_oni = storm_oni.iloc[0]
+                        
+                        phase = classify_enso_phases(storm_oni)
+                        
+                        if (enso_value == 'all' or 
+                            (enso_value == 'el_nino' and phase == 'El Nino') or
+                            (enso_value == 'la_nina' and phase == 'La Nina') or
+                            (enso_value == 'neutral' and phase == 'Neutral')):
+                            
+                            color = {'El Nino': 'red', 'La Nina': 'blue', 'Neutral': 'green'}[phase]
+                            
+                            # Highlight searched typhoon
+                            if typhoon_search and typhoon_search.lower() in storm.name.lower():
+                                line_width = 5
+                                line_color = 'yellow'
+                            else:
+                                line_width = 2
+                                line_color = color
+                            
+                            fig_tracks.add_trace(go.Scattergeo(
+                                lon=storm.lon,
+                                lat=storm.lat,
+                                mode='lines',
+                                name=storm.name,
+                                text=f'{storm.name} ({year})',
+                                hoverinfo='text',
+                                line=dict(width=line_width, color=line_color)
+                            ))
         
-        # Add initial track and starting point
-        fig.add_trace(
-            go.Scattergeo(
-                lon=storm.lon,
-                lat=storm.lat,
-                mode='lines',
-                line=dict(width=2, color='gray'),
-                name='Complete Path',
-                showlegend=True,
-            )
-        )
-
-        fig.add_trace(
-            go.Scattergeo(
-                lon=[storm.lon[0]],
-                lat=[storm.lat[0]],
-                mode='markers',
-                marker=dict(size=10, color='green', symbol='star'),
-                name='Starting Point',
-                text=storm.time[0].strftime('%Y-%m-%d %H:%M'),
-                hoverinfo='text+name',
+        fig_tracks.update_layout(
+            title=f'Typhoon Tracks from {start_year}-{start_month} to {end_year}-{end_month}',
+            geo=dict(
+                projection_type='natural earth',
+                showland=True,
+                coastlinecolor='rgb(100, 100, 100)',
+                countrycolor='rgb(204, 204, 204)',
             )
         )
-
-        # Add slider for frame selection
-        sliders = [{
-            "active": 0,
-            "yanchor": "top",
-            "xanchor": "left",
-            "currentvalue": {
-                "font": {"size": 20},
-                "prefix": "Time: ",
-                "visible": True,
-                "xanchor": "right"
-            },
-            "transition": {"duration": 100, "easing": "cubic-in-out"},
-            "pad": {"b": 10, "t": 50},
-            "len": 0.9,
-            "x": 0.1,
-            "y": 0,
-            "steps": [
-                {
-                    "args": [[f"frame{k}"],
-                            {"frame": {"duration": 100, "redraw": True},
-                            "mode": "immediate",
-                            "transition": {"duration": 0}}
-                            ],
-                    "label": storm.time[k].strftime('%Y-%m-%d %H:%M'),
-                    "method": "animate"
-                }
-                for k in range(len(storm.time))
-            ]
-        }]
         
-        fig.update_layout(sliders=sliders)
-
-        info_text = f"""
-        ### Typhoon Information
-        - **Name:** {storm.name}
-        - **Start Date:** {storm.time[0].strftime('%Y-%m-%d %H:%M')}
-        - **End Date:** {storm.time[-1].strftime('%Y-%m-%d %H:%M')}
-        - **Duration:** {(storm.time[-1] - storm.time[0]).total_seconds() / 3600:.1f} hours
-        - **Maximum Wind Speed:** {max(storm.vmax):.1f} kt
-        - **Minimum Pressure:** {min(storm.mslp):.1f} hPa
-        - **Peak Category:** {self.categorize_typhoon_by_standard(max(storm.vmax), standard)[0]}
-        """
-
-        return fig, info_text
-
-    def search_typhoons(self, query):
-        """Search for typhoons by name"""
-        if not query:
-            return go.Figure(), "Please enter a typhoon name to search"
+        # Calculate statistics for this period
+        filtered_data = merged_data[
+            (merged_data['Year'] >= int(start_year)) & 
+            (merged_data['Year'] <= int(end_year)) & 
+            (merged_data['Month'].astype(int) >= int(start_month)) & 
+            (merged_data['Month'].astype(int) <= int(end_month))
+        ]
+        
+        max_wind = filtered_data['USA_WIND'].max() if not filtered_data.empty else 0
+        min_press = filtered_data['USA_PRES'].min() if not filtered_data.empty else 0
         
-        # Find all typhoons matching the query
-        matching_storms = []
+        stats_text = f"Maximum Wind Speed: {max_wind:.2f} knots\nMinimum Pressure: {min_press:.2f} hPa"
         
-        # Limit search to last 30 years to improve performance
-        current_year = datetime.now().year
-        start_year = current_year - 30
+        # Create wind scatter plot
+        wind_oni_scatter = 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': 'Maximum Wind Speed (knots)'},
+                                    color_discrete_map=color_map)
         
-        for year in range(start_year, current_year + 1):
-            try:
-                season = self.ibtracs.get_season(year)
-                for storm_id in season.summary()['id']:
-                    storm = self.ibtracs.get_storm(storm_id)
-                    if query.lower() in storm.name.lower():
-                        matching_storms.append((year, storm))
-            except Exception as e:
-                print(f"Error searching year {year}: {str(e)}")
+        # Create pressure scatter plot
+        pressure_oni_scatter = 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': 'Minimum Pressure (hPa)'},
+                                        color_discrete_map=color_map)
+        
+        return fig_tracks, wind_oni_scatter, pressure_oni_scatter, stats_text
+    except Exception as e:
+        error_fig = go.Figure()
+        error_fig.add_annotation(text=f"Error: {str(e)}", xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False)
+        return error_fig, error_fig, error_fig, f"Error analyzing typhoon tracks: {str(e)}"
+
+# Function to run cluster analysis
+def run_cluster_analysis(start_year, start_month, end_year, end_month, n_clusters, enso_selection, analysis_type):
+    start_date = datetime(int(start_year), int(start_month), 1)
+    end_date = datetime(int(end_year), int(end_month), 28)
+    
+    # Map Gradio dropdown values to the values used in the original code
+    enso_map = {
+        "All Years": "all", 
+        "El Niño Years": "el_nino", 
+        "La Niña Years": "la_nina", 
+        "Neutral Years": "neutral"
+    }
+    enso_value = enso_map[enso_selection]
+    
+    fig_routes = go.Figure()
+    
+    try:
+        # Clustering analysis
+        west_pacific_storms = []
+        for year in range(int(start_year), int(end_year) + 1):
+            if year not in ibtracs.data.keys():
                 continue
+            
+            season = ibtracs.get_season(year)
+            for storm_id in season.summary()['id']:
+                storm = get_storm_data(storm_id)
+                storm_date = storm.time[0]
+                
+                # Try to find the ONI value for this storm date
+                date_str = storm_date.strftime('%Y-%b')
+                if date_str in oni_df.index:
+                    storm_oni = oni_df.loc[date_str]['ONI']
+                    if isinstance(storm_oni, pd.Series):
+                        storm_oni = storm_oni.iloc[0]
+                    storm_phase = classify_enso_phases(storm_oni)
+                    
+                    if enso_value == 'all' or \
+                       (enso_value == 'el_nino' and storm_phase == 'El Nino') or \
+                       (enso_value == 'la_nina' and storm_phase == 'La Nina') or \
+                       (enso_value == 'neutral' and storm_phase == 'Neutral'):
+                        lons, lats = filter_west_pacific_coordinates(np.array(storm.lon), np.array(storm.lat))
+                        if len(lons) > 1:  # Ensure the storm has a valid path in West Pacific
+                            west_pacific_storms.append((lons, lats))
         
-        if not matching_storms:
-            return go.Figure(), "No typhoons found matching your search"
+        if not west_pacific_storms:
+            return None, "No storms found matching the criteria"
         
-        # Create visualization of all matching typhoons
-        fig = go.Figure()
+        max_length = max(len(storm[0]) for storm in west_pacific_storms)
+        standardized_routes = []
         
-        fig.update_layout(
-            title=f"Typhoons Matching: '{query}'",
+        for lons, lats in west_pacific_storms:
+            if len(lons) < 2:  # Skip if not enough points
+                continue
+            t = np.linspace(0, 1, len(lons))
+            t_new = np.linspace(0, 1, max_length)
+            lon_interp = interp1d(t, lons, kind='linear')(t_new)
+            lat_interp = interp1d(t, lats, kind='linear')(t_new)
+            route_vector = np.column_stack((lon_interp, lat_interp)).flatten()
+            standardized_routes.append(route_vector)
+        
+        if not standardized_routes:
+            return None, "Unable to create standardized routes"
+        
+        kmeans = KMeans(n_clusters=int(n_clusters), random_state=42, n_init=10)
+        clusters = kmeans.fit_predict(standardized_routes)
+        
+        # Count the number of typhoons in each cluster
+        cluster_counts = np.bincount(clusters)
+        
+        # Draw all routes (with lighter color)
+        if analysis_type == "Show Routes":
+            for lons, lats in west_pacific_storms:
+                fig_routes.add_trace(go.Scattergeo(
+                    lon=lons, lat=lats,
+                    mode='lines',
+                    line=dict(width=1, color='lightgray'),
+                    showlegend=False,
+                    hoverinfo='none'
+                ))
+        
+        equations_output = ""
+        # Draw cluster centroids
+        if analysis_type == "Show Clusters" or analysis_type == "Fourier Series":
+            for i in range(int(n_clusters)):
+                cluster_center = kmeans.cluster_centers_[i].reshape(-1, 2)
+                
+                fig_routes.add_trace(go.Scattergeo(
+                    lon=cluster_center[:, 0],
+                    lat=cluster_center[:, 1],
+                    mode='lines',
+                    name=f'Cluster {i+1} (n={cluster_counts[i]})',
+                    line=dict(width=3)
+                ))
+                
+                if analysis_type == "Fourier Series":
+                    cluster_equations, (lon_min, lon_max) = generate_cluster_equations(cluster_center)
+                    
+                    equations_output += f"\n--- Cluster {i+1} (Typhoons: {cluster_counts[i]}) ---\n"
+                    for name, eq in cluster_equations:
+                        equations_output += f"{name}: {eq}\n"
+                    
+                    equations_output += "\nTo use in GeoGebra:\n"
+                    equations_output += f"1. Set x-axis from 0 to {2*np.pi:.4f}\n"
+                    equations_output += "2. Use the equation as is\n"
+                    equations_output += f"3. To convert x back to longitude: lon = {lon_min:.4f} + x * {(lon_max - lon_min) / (2*np.pi):.4f}\n\n"
+        
+        enso_phase_text = {
+            'all': 'All Years',
+            'el_nino': 'El Niño Years',
+            'la_nina': 'La Niña Years',
+            'neutral': 'Neutral Years'
+        }
+        
+        fig_routes.update_layout(
+            title=f'Typhoon Routes Clustering in West Pacific ({start_year}-{end_year}) - {enso_phase_text[enso_value]}',
             geo=dict(
-                projection_type='natural earth',
+                projection_type='mercator',
                 showland=True,
                 landcolor='rgb(243, 243, 243)',
                 countrycolor='rgb(204, 204, 204)',
                 coastlinecolor='rgb(100, 100, 100)',
                 showocean=True,
                 oceancolor='rgb(230, 250, 255)',
-                lataxis=dict(range=[0, 50]),
-                lonaxis=dict(range=[100, 180]),
-                center=dict(lat=20, lon=140),
-            )
+                lataxis={'range': [0, 40]},
+                lonaxis={'range': [100, 180]},
+                center={'lat': 20, 'lon': 140},
+            ),
+            legend_title='Clusters'
         )
         
-        # Plot each matching storm with a different color
-        colors = px.colors.qualitative.Plotly
+        return fig_routes, equations_output
+    except Exception as e:
+        error_fig = go.Figure()
+        error_fig.add_annotation(text=f"Error: {str(e)}", xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False)
+        return error_fig, f"Error in cluster analysis: {str(e)}"
+
+# Function to perform logistic regression
+def perform_logistic_regression(start_year, start_month, end_year, end_month, regression_type):
+    start_date = datetime(int(start_year), int(start_month), 1)
+    end_date = datetime(int(end_year), int(end_month), 28)
+    
+    try:
+        filtered_data = merged_data[
+            (merged_data['ISO_TIME'] >= start_date) & 
+            (merged_data['ISO_TIME'] <= end_date)
+        ]
         
-        for i, (year, storm) in enumerate(matching_storms):
-            color = colors[i % len(colors)]
+        if regression_type == "Wind Speed":
+            filtered_data['severe_typhoon'] = (filtered_data['USA_WIND'] >= 64).astype(int)  # 64 knots threshold for severe typhoons
+            X = sm.add_constant(filtered_data['ONI'])
+            y = filtered_data['severe_typhoon']
+            model = sm.Logit(y, X).fit()
             
-            fig.add_trace(go.Scattergeo(
-                lon=storm.lon,
-                lat=storm.lat,
-                mode='lines',
-                line=dict(width=3, color=color),
-                name=f"{storm.name} ({year})",
-                hovertemplate=(
-                    f"Name: {storm.name}<br>"
-                    f"Year: {year}<br>"
-                    f"Max Wind: {max(storm.vmax):.1f} kt<br>"
-                    f"Min Pressure: {min(storm.mslp):.1f} hPa<br>"
-                    f"Position: %{lat:.2f}°N, %{lon:.2f}°E"
-                )
-            ))
-        
-        # Add starting points
-        for i, (year, storm) in enumerate(matching_storms):
-            color = colors[i % len(colors)]
+            beta_1 = model.params['ONI']
+            exp_beta_1 = np.exp(beta_1)
+            p_value = model.pvalues['ONI']
             
-            fig.add_trace(go.Scattergeo(
-                lon=[storm.lon[0]],
-                lat=[storm.lat[0]],
-                mode='markers',
-                marker=dict(size=10, color=color, symbol='circle'),
-                name=f"Start: {storm.name} ({year})",
-                showlegend=False,
-                hoverinfo='name'
-            ))
-        
-        # Create information text
-        info_text = f"### Found {len(matching_storms)} typhoons matching '{query}':\n\n"
-        
-        for year, storm in matching_storms:
-            info_text += f"- **{storm.name} ({year})**\n"
-            info_text += f"  - Time: {storm.time[0].strftime('%Y-%m-%d')} to {storm.time[-1].strftime('%Y-%m-%d')}\n"
-            info_text += f"  - Max Wind: {max(storm.vmax):.1f} kt\n"
-            info_text += f"  - Min Pressure: {min(storm.mslp):.1f} hPa\n"
-            info_text += f"  - Category: {self.categorize_typhoon_by_standard(max(storm.vmax))[0]}\n\n"
-        
-        return fig, info_text
-
-    def categorize_typhoon_by_standard(self, wind_speed, standard='atlantic'):
-        """
-        Categorize typhoon based on wind speed and chosen standard
-        wind_speed is in knots
-        """
-        if standard == 'taiwan':
-            # Convert knots to m/s for Taiwan standard
-            wind_speed_ms = wind_speed * 0.514444
+            el_nino_data = filtered_data[filtered_data['ONI'] >= 0.5]
+            la_nina_data = filtered_data[filtered_data['ONI'] <= -0.5]
+            neutral_data = filtered_data[(filtered_data['ONI'] > -0.5) & (filtered_data['ONI'] < 0.5)]
             
-            if wind_speed_ms >= 51.0:
-                return 'Strong Typhoon', 'rgb(255, 0, 0)'
-            elif wind_speed_ms >= 33.7:
-                return 'Medium Typhoon', 'rgb(255, 127, 0)'
-            elif wind_speed_ms >= 17.2:
-                return 'Mild Typhoon', 'rgb(255, 255, 0)'
-            else:
-                return 'Tropical Depression', 'rgb(173, 216, 230)'
-        else:
-            # Atlantic standard uses knots
-            if wind_speed >= 137:
-                return 'C5 Super Typhoon', 'rgb(255, 0, 0)'
-            elif wind_speed >= 113:
-                return 'C4 Very Strong Typhoon', 'rgb(255, 63, 0)'
-            elif wind_speed >= 96:
-                return 'C3 Strong Typhoon', 'rgb(255, 127, 0)'
-            elif wind_speed >= 83:
-                return 'C2 Typhoon', 'rgb(255, 191, 0)'
-            elif wind_speed >= 64:
-                return 'C1 Typhoon', 'rgb(255, 255, 0)'
-            elif wind_speed >= 34:
-                return 'Tropical Storm', 'rgb(0, 255, 255)'
-            else:
-                return 'Tropical Depression', 'rgb(173, 216, 230)'
+            el_nino_severe = el_nino_data['severe_typhoon'].mean() if not el_nino_data.empty else 0
+            la_nina_severe = la_nina_data['severe_typhoon'].mean() if not la_nina_data.empty else 0
+            neutral_severe = neutral_data['severe_typhoon'].mean() if not neutral_data.empty else 0
+            
+            result = f"""
+            # Wind Speed Logistic Regression Results
+            
+            β1 (ONI coefficient): {beta_1:.4f}
+            exp(β1) (Odds Ratio): {exp_beta_1:.4f}
+            P-value: {p_value:.4f}
+            
+            Interpretation:
+            - For each unit increase in ONI, the odds of a severe typhoon are {"increased" if exp_beta_1 > 1 else "decreased"} by a factor of {exp_beta_1:.2f}.
+            - This effect is {"statistically significant" if p_value < 0.05 else "not statistically significant"} at the 0.05 level.
+            
+            Proportion of severe typhoons:
+            - El Niño conditions: {el_nino_severe:.2%}
+            - La Niña conditions: {la_nina_severe:.2%}
+            - Neutral conditions: {neutral_severe:.2%}
+            """
+            
+        elif regression_type == "Pressure":
+            filtered_data['intense_typhoon'] = (filtered_data['USA_PRES'] <= 950).astype(int)  # 950 hPa threshold for intense typhoons
+            X = sm.add_constant(filtered_data['ONI'])
+            y = filtered_data['intense_typhoon']
+            model = sm.Logit(y, X).fit()
+            
+            beta_1 = model.params['ONI']
+            exp_beta_1 = np.exp(beta_1)
+            p_value = model.pvalues['ONI']
+            
+            el_nino_data = filtered_data[filtered_data['ONI'] >= 0.5]
+            la_nina_data = filtered_data[filtered_data['ONI'] <= -0.5]
+            neutral_data = filtered_data[(filtered_data['ONI'] > -0.5) & (filtered_data['ONI'] < 0.5)]
+            
+            el_nino_intense = el_nino_data['intense_typhoon'].mean() if not el_nino_data.empty else 0
+            la_nina_intense = la_nina_data['intense_typhoon'].mean() if not la_nina_data.empty else 0
+            neutral_intense = neutral_data['intense_typhoon'].mean() if not neutral_data.empty else 0
+            
+            result = f"""
+            # Pressure Logistic Regression Results
+            
+            β1 (ONI coefficient): {beta_1:.4f}
+            exp(β1) (Odds Ratio): {exp_beta_1:.4f}
+            P-value: {p_value:.4f}
+            
+            Interpretation:
+            - For each unit increase in ONI, the odds of an intense typhoon (pressure <= 950 hPa) are {"increased" if exp_beta_1 > 1 else "decreased"} by a factor of {exp_beta_1:.2f}.
+            - This effect is {"statistically significant" if p_value < 0.05 else "not statistically significant"} at the 0.05 level.
+            
+            Proportion of intense typhoons:
+            - El Niño conditions: {el_nino_intense:.2%}
+            - La Niña conditions: {la_nina_intense:.2%}
+            - Neutral conditions: {neutral_intense:.2%}
+            """
+            
+        elif regression_type == "Longitude":
+            filtered_data = filtered_data.dropna(subset=['LON'])
+            
+            if len(filtered_data) == 0:
+                return "Insufficient data for longitude analysis"
+            
+            filtered_data['western_typhoon'] = (filtered_data['LON'] <= 140).astype(int)  # 140°E as threshold for western typhoons
+            X = sm.add_constant(filtered_data['ONI'])
+            y = filtered_data['western_typhoon']
+            model = sm.Logit(y, X).fit()
+            
+            beta_1 = model.params['ONI']
+            exp_beta_1 = np.exp(beta_1)
+            p_value = model.pvalues['ONI']
+            
+            el_nino_data = filtered_data[filtered_data['ONI'] >= 0.5]
+            la_nina_data = filtered_data[filtered_data['ONI'] <= -0.5]
+            neutral_data = filtered_data[(filtered_data['ONI'] > -0.5) & (filtered_data['ONI'] < 0.5)]
+            
+            el_nino_western = el_nino_data['western_typhoon'].mean() if not el_nino_data.empty else 0
+            la_nina_western = la_nina_data['western_typhoon'].mean() if not la_nina_data.empty else 0
+            neutral_western = neutral_data['western_typhoon'].mean() if not neutral_data.empty else 0
+            
+            result = f"""
+            # Longitude Logistic Regression Results
+            
+            β1 (ONI coefficient): {beta_1:.4f}
+            exp(β1) (Odds Ratio): {exp_beta_1:.4f}
+            P-value: {p_value:.4f}
+            
+            Interpretation:
+            - For each unit increase in ONI, the odds of a typhoon forming west of 140°E are {"increased" if exp_beta_1 > 1 else "decreased"} by a factor of {exp_beta_1:.2f}.
+            - This effect is {"statistically significant" if p_value < 0.05 else "not statistically significant"} at the 0.05 level.
+            
+            Proportion of typhoons forming west of 140°E:
+            - El Niño conditions: {el_nino_western:.2%}
+            - La Niña conditions: {la_nina_western:.2%}
+            - Neutral conditions: {neutral_western:.2%}
+            """
+        
+        return result
+    except Exception as e:
+        return f"Error performing logistic regression: {str(e)}"
 
+# Define Gradio interface
 def create_interface():
-    analyzer = TyphoonAnalyzer()
-
-    with gr.Blocks(title="Typhoon Analysis Dashboard", theme=gr.themes.Base()) as demo:
+    # Initialize data first
+    initialize_data()
+    
+    # Define interface tabs
+    with gr.Blocks(title="Typhoon Analysis Dashboard") as demo:
         gr.Markdown("# Typhoon Analysis Dashboard")
         
-        with gr.Tabs():
-            # Main Analysis Tab
-            with gr.Tab("Main Analysis"):
-                with gr.Row():
-                    with gr.Column():
-                        start_year = gr.Slider(1900, 2024, 2000, label="Start Year")
-                        start_month = gr.Slider(1, 12, 1, label="Start Month")
-                    with gr.Column():
-                        end_year = gr.Slider(1900, 2024, 2024, label="End Year")
-                        end_month = gr.Slider(1, 12, 12, label="End Month")
-                
-                enso_dropdown = gr.Dropdown(
-                    choices=["all", "el_nino", "la_nina", "neutral"],
-                    value="all",
+        with gr.Tab("Typhoon Tracks Analysis"):
+            with gr.Row():
+                with gr.Column():
+                    start_year = gr.Number(value=2000, label="Start Year", minimum=1950, maximum=2024, step=1)
+                    start_month = gr.Number(value=1, label="Start Month", minimum=1, maximum=12, step=1)
+                with gr.Column():
+                    end_year = gr.Number(value=2024, label="End Year", minimum=1950, maximum=2024, step=1)
+                    end_month = gr.Number(value=6, label="End Month", minimum=1, maximum=12, step=1)
+            
+            enso_dropdown = gr.Dropdown(
+                choices=["All Years", "El Niño Years", "La Niña Years", "Neutral Years"],
+                value="All Years",
+                label="ENSO Phase"
+            )
+            
+            typhoon_search = gr.Textbox(label="Search Typhoon Name")
+            
+            analyze_button = gr.Button("Analyze Tracks")
+            
+            with gr.Row():
+                tracks_plot = gr.Plot(label="Typhoon Tracks")
+                stats_text = gr.Textbox(label="Statistics", lines=4)
+            
+            with gr.Row():
+                wind_plot = gr.Plot(label="Wind Speed vs ONI")
+                pressure_plot = gr.Plot(label="Pressure vs ONI")
+            
+            analyze_button.click(
+                analyze_typhoon_tracks,
+                inputs=[start_year, start_month, end_year, end_month, enso_dropdown, typhoon_search],
+                outputs=[tracks_plot, wind_plot, pressure_plot, stats_text]
+            )
+        
+        with gr.Tab("Clustering Analysis"):
+            with gr.Row():
+                with gr.Column():
+                    cluster_start_year = gr.Number(value=2000, label="Start Year", minimum=1950, maximum=2024, step=1)
+                    cluster_start_month = gr.Number(value=1, label="Start Month", minimum=1, maximum=12, step=1)
+                with gr.Column():
+                    cluster_end_year = gr.Number(value=2024, label="End Year", minimum=1950, maximum=2024, step=1)
+                    cluster_end_month = gr.Number(value=6, label="End Month", minimum=1, maximum=12, step=1)
+            
+            with gr.Row():
+                n_clusters = gr.Number(value=5, label="Number of Clusters", minimum=1, maximum=20, step=1)
+                cluster_enso_dropdown = gr.Dropdown(
+                    choices=["All Years", "El Niño Years", "La Niña Years", "Neutral Years"],
+                    value="All Years",
                     label="ENSO Phase"
                 )
+            
+            analysis_type = gr.Radio(
+                choices=["Show Routes", "Show Clusters", "Fourier Series"],
+                value="Show Clusters", 
+                label="Analysis Type"
+            )
+            
+            cluster_button = gr.Button("Run Cluster Analysis")
+            
+            cluster_plot = gr.Plot(label="Typhoon Routes Clustering")
+            equation_text = gr.Textbox(label="Cluster Equations", lines=15)
+            
+            cluster_button.click(
+                run_cluster_analysis,
+                inputs=[
+                    cluster_start_year, cluster_start_month, cluster_end_year, 
+                    cluster_end_month, n_clusters, cluster_enso_dropdown, analysis_type
+                ],
+                outputs=[cluster_plot, equation_text]
+            )
+        
+        with gr.Tab("Regression Analysis"):
+            with gr.Row():
+                with gr.Column():
+                    reg_start_year = gr.Number(value=2000, label="Start Year", minimum=1950, maximum=2024, step=1)
+                    reg_start_month = gr.Number(value=1, label="Start Month", minimum=1, maximum=12, step=1)
+                with gr.Column():
+                    reg_end_year = gr.Number(value=2024, label="End Year", minimum=1950, maximum=2024, step=1)
+                    reg_end_month = gr.Number(value=6, label="End Month", minimum=1, maximum=12, step=1)
+            
+            regression_type = gr.Radio(
+                choices=["Wind Speed", "Pressure", "Longitude"],
+                value="Wind Speed", 
+                label="Regression Type"
+            )
+            
+            regression_button = gr.Button("Perform Logistic Regression")
+            
+            regression_results = gr.Textbox(label="Regression Results", lines=15)
+            
+            regression_button.click(
+                perform_logistic_regression,
+                inputs=[reg_start_year, reg_start_month, reg_end_year, reg_end_month, regression_type],
+                outputs=regression_results
+            )
+        
+        with gr.Tab("Typhoon Path Animation"):
+            with gr.Row():
+                year_dropdown = gr.Dropdown(
+                    choices=[str(year) for year in range(1950, 2025)],
+                    value="2024",
+                    label="Year"
+                )
                 
-                analyze_btn = gr.Button("Analyze")
-                
-                tracks_plot = gr.Plot(label="Typhoon Tracks")
-                
-                with gr.Row():
-                    wind_plot = gr.Plot(label="Wind Speed Analysis")
-                    pressure_plot = gr.Plot(label="Pressure Analysis")
-                
-                stats_text = gr.Markdown()
-
-            # Typhoon Animation Tab
-            with gr.Tab("Typhoon Animation"):
-                with gr.Row():
-                    animation_year = gr.Slider(
-                        minimum=1950, 
-                        maximum=2024, 
-                        value=2020,
-                        step=1,
-                        label="Select Year"
-                    )
-                
-                with gr.Row():
-                    animation_typhoon = gr.Dropdown(
-                        choices=[],
-                        label="Select Typhoon",
-                        interactive=True
-                    )
-                    
-                    standard_dropdown = gr.Dropdown(
-                        choices=[
-                            {"label": "Atlantic Standard", "value": "atlantic"},
-                            {"label": "Taiwan Standard", "value": "taiwan"}
-                        ],
-                        value="atlantic",
-                        label="Classification Standard"
-                    )
-                
-                animation_btn = gr.Button("Show Typhoon Path", variant="primary")
-                animation_plot = gr.Plot(label="Typhoon Path Animation")
-                animation_info = gr.Markdown()
-
-            # Search Tab
-            with gr.Tab("Typhoon Search"):
-                with gr.Row():
-                    search_input = gr.Textbox(label="Search Typhoon Name")
-                    search_btn = gr.Button("Search Typhoons", variant="primary")
+                typhoon_dropdown = gr.Dropdown(
+                    label="Typhoon",
+                    interactive=True
+                )
                 
-                search_results = gr.Plot(label="Search Results")
-                search_info = gr.Markdown()
-
-        # Event handlers
-        def analyze_callback(start_y, start_m, end_y, end_m, enso):
-            results = analyzer.analyze_typhoon(start_y, start_m, end_y, end_m, enso)
-            return [
-                results['tracks'],
-                results['wind'],
-                results['pressure'],
-                results['stats']
-            ]
-
-        def update_typhoon_choices(year):
-            typhoons = analyzer.get_typhoons_for_year(year)
-            return gr.update(choices=typhoons, value=None)
-
-        # Connect events for main analysis
-        analyze_btn.click(
-            analyze_callback,
-            inputs=[start_year, start_month, end_year, end_month, enso_dropdown],
-            outputs=[tracks_plot, wind_plot, pressure_plot, stats_text]
-        )
-
-        # Connect events for Animation tab
-        animation_year.change(
-            update_typhoon_choices,
-            inputs=[animation_year],
-            outputs=[animation_typhoon]
-        )
-
-        animation_btn.click(
-            analyzer.create_typhoon_animation,
-            inputs=[animation_year, animation_typhoon, standard_dropdown],
-            outputs=[animation_plot, animation_info]
-        )
-
-        # Connect events for Search tab
-        search_btn.click(
-            analyzer.search_typhoons,
-            inputs=[search_input],
-            outputs=[search_results, search_info]
-        )
-
+                standard_dropdown = gr.Dropdown(
+                    choices=["atlantic", "taiwan"],
+                    value="atlantic",
+                    label="Classification Standard"
+                )
+            
+            # Update typhoon dropdown when year changes
+            year_dropdown.change(
+                lambda year: (
+                    [{"label": name, "value": id} for name, id in get_typhoons_for_year(year)],
+                    get_typhoons_for_year(year)[0][1] if get_typhoons_for_year(year) else None
+                ),
+                inputs=year_dropdown,
+                outputs=[typhoon_dropdown, typhoon_dropdown]
+            )
+            
+            animation_button = gr.Button("Generate Animation")
+            
+            typhoon_animation = gr.Plot(label="Typhoon Path Animation")
+            
+            animation_button.click(
+                create_typhoon_path_animation,
+                inputs=[year_dropdown, typhoon_dropdown, standard_dropdown],
+                outputs=typhoon_animation
+            )
+    
     return demo
 
+# Run the app
 if __name__ == "__main__":
+    # Schedule background tasks
+    schedule.every().day.at("01:00").do(update_ibtracs_data)
+    schedule.every().day.at("00:00").do(lambda: update_oni_data() if should_update_oni() else None)
+    scheduler_thread = threading.Thread(target=run_schedule)
+    scheduler_thread.daemon = True
+    scheduler_thread.start()
+    
+    # Create and launch the Gradio interface
     demo = create_interface()
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=True
-    )
+    demo.launch(server_name="127.0.0.1", server_port=7860)