modulizatioin

api_utils.py

@@ -0,0 +1,206 @@
+from datetime import datetime, timedelta
+import pandas as pd
+import pytz
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+
+from supabase_utils import get_supabase_client
+from config import STATION_NAMES
+
+def api_get_current_tide(station_id):
+    """현재 조위 조회"""
+    supabase = get_supabase_client()
+    if not supabase:
+        return {"error": "Supabase 클라이언트를 생성할 수 없습니다."}
+
+    try:
+        result = supabase.table('tide_predictions') \
+            .select('predicted_at, final_tide_level') \
+            .eq('station_id', station_id) \
+            .order('predicted_at', desc=True) \
+            .limit(1) \
+            .execute()
+
+        if result.data:
+            return result.data[0]
+        else:
+            return {"error": "데이터가 없습니다."}
+    except Exception as e:
+        return {"error": f"데이터 조회 오류: {e}"}
+
+def api_get_historical_tide(station_id, date_str, hours=24):
+    """과거 특정 날짜의 조위 데이터 조회"""
+    supabase = get_supabase_client()
+    if not supabase:
+        return {"error": "Supabase 클라이언트를 생성할 수 없습니다."}
+
+    try:
+        start_time = datetime.strptime(date_str, '%Y-%m-%d')
+        start_time_kst = pytz.timezone('Asia/Seoul').localize(start_time)
+        end_time_kst = start_time_kst + timedelta(hours=hours)
+
+        start_utc = start_time_kst.astimezone(pytz.UTC).isoformat()
+        end_utc = end_time_kst.astimezone(pytz.UTC).isoformat()
+
+        result = supabase.table('historical_tide') \
+            .select('observed_at, tide_level') \
+            .eq('station_id', station_id) \
+            .gte('observed_at', start_utc) \
+            .lte('observed_at', end_utc) \
+            .order('observed_at') \
+            .execute()
+
+        if not result.data:
+            return {"error": f"{date_str}에 대한 과거 데이터가 없습니다."}
+
+        df = pd.DataFrame(result.data)
+        df['observed_at'] = pd.to_datetime(df['observed_at']).dt.tz_convert('Asia/Seoul')
+        df['tide_level'] = pd.to_numeric(df['tide_level'])
+
+        fig = go.Figure()
+        fig.add_trace(go.Scatter(x=df['observed_at'], y=df['tide_level'], mode='lines',
+                                name=f'{STATION_NAMES.get(station_id, station_id)} 조위'))
+        fig.update_layout(
+            title=f'{STATION_NAMES.get(station_id, station_id)} - {date_str} 조위',
+            xaxis_title='시간',
+            yaxis_title='조위 (cm)',
+            height=400
+        )
+        return fig
+
+    except Exception as e:
+        return {"error": f"데이터 조회 중 오류 발생: {e}"}
+
+def api_get_historical_extremes(station_id, date_str):
+    """과거 특정 날짜의 만조/간조 정보"""
+    supabase = get_supabase_client()
+    if not supabase:
+        return {"error": "Supabase 클라이언트를 생성할 수 없습니다."}
+
+    try:
+        start_time = datetime.strptime(date_str, '%Y-%m-%d')
+        start_time_kst = pytz.timezone('Asia/Seoul').localize(start_time)
+        end_time_kst = start_time_kst + timedelta(days=1)
+
+        start_utc = start_time_kst.astimezone(pytz.UTC).isoformat()
+        end_utc = end_time_kst.astimezone(pytz.UTC).isoformat()
+
+        result = supabase.table('historical_tide') \
+            .select('observed_at, tide_level') \
+            .eq('station_id', station_id) \
+            .gte('observed_at', start_utc) \
+            .lte('observed_at', end_utc) \
+            .order('observed_at') \
+            .execute()
+
+        if not result.data or len(result.data) < 3:
+            return {"error": f"{date_str}의 만조/간조를 계산할 데이터가 부족합니다."}
+
+        df = pd.DataFrame(result.data)
+        df['observed_at'] = pd.to_datetime(df['observed_at']).dt.tz_convert('Asia/Seoul')
+        df['tide_level'] = pd.to_numeric(df['tide_level'])
+
+        df['min'] = df.tide_level[(df.tide_level.shift(1) > df.tide_level) & (df.tide_level.shift(-1) > df.tide_level)]
+        df['max'] = df.tide_level[(df.tide_level.shift(1) < df.tide_level) & (df.tide_level.shift(-1) < df.tide_level)]
+
+        extremes_df = df.dropna(subset=['min', 'max'], how='all').copy()
+        extremes_df['type'] = extremes_df.apply(lambda row: '만조' if pd.notna(row['max']) else '간조', axis=1)
+        extremes_df['value'] = extremes_df.apply(lambda row: row['max'] if pd.notna(row['max']) else row['min'], axis=1)
+        extremes_df['time'] = extremes_df['observed_at'].dt.strftime('%H:%M')
+
+        return extremes_df[['time', 'type', 'value']]
+
+    except Exception as e:
+        return {"error": f"데이터 처리 중 오류 발생: {e}"}
+
+def api_compare_dates(station_id, date1, date2):
+    """두 날짜의 조위 패턴 비교"""
+    supabase = get_supabase_client()
+    if not supabase:
+        return {"error": "Supabase 클라이언트를 생성할 수 없습니다."}
+
+    def get_data_for_date(target_date):
+        start = pytz.timezone('Asia/Seoul').localize(datetime.strptime(target_date, '%Y-%m-%d'))
+        end = start + timedelta(days=1)
+        res = supabase.table('historical_tide') \
+            .select('observed_at, tide_level') \
+            .eq('station_id', station_id) \
+            .gte('observed_at', start.astimezone(pytz.UTC).isoformat()) \
+            .lte('observed_at', end.astimezone(pytz.UTC).isoformat()) \
+            .order('observed_at') \
+            .execute()
+        return res.data
+
+    data1 = get_data_for_date(date1)
+    data2 = get_data_for_date(date2)
+
+    if not data1 or not data2:
+        return {"error": "두 날짜 중 하나의 데이터가 없습니다."}
+
+    df1 = pd.DataFrame(data1)
+    df1['tide_level'] = pd.to_numeric(df1['tide_level'])
+    df1['minutes_from_start'] = (pd.to_datetime(df1['observed_at']) - pd.to_datetime(df1['observed_at']).iloc[0]).dt.total_seconds() / 60
+
+    df2 = pd.DataFrame(data2)
+    df2['tide_level'] = pd.to_numeric(df2['tide_level'])
+    df2['minutes_from_start'] = (pd.to_datetime(df2['observed_at']) - pd.to_datetime(df2['observed_at']).iloc[0]).dt.total_seconds() / 60
+
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(x=df1['minutes_from_start'], y=df1['tide_level'], mode='lines', name=date1))
+    fig.add_trace(go.Scatter(x=df2['minutes_from_start'], y=df2['tide_level'], mode='lines', name=date2))
+    fig.update_layout(title=f'{STATION_NAMES.get(station_id, station_id)} 조위 비교: {date1} vs {date2}',
+                      xaxis_title='자정부터 경과 시간(분)', yaxis_title='조위 (cm)')
+    return fig
+
+def api_get_monthly_summary(station_id, year, month):
+    """월간 조위 요약 통계"""
+    supabase = get_supabase_client()
+    if not supabase:
+        return {"error": "Supabase 클라이언트를 생성할 수 없습니다."}
+
+    try:
+        start_date = f"{year}-{int(month):02d}-01"
+        end_date = (datetime.strptime(start_date, '%Y-%m-%d') + pd.offsets.MonthEnd(1)).strftime('%Y-%m-%d')
+
+        start_utc = pytz.timezone('Asia/Seoul').localize(datetime.strptime(start_date, '%Y-%m-%d')).astimezone(pytz.UTC).isoformat()
+        end_utc = (pytz.timezone('Asia/Seoul').localize(datetime.strptime(end_date, '%Y-%m-%d')) + timedelta(days=1)).astimezone(pytz.UTC).isoformat()
+
+        result = supabase.table('historical_tide') \
+            .select('observed_at, tide_level') \
+            .eq('station_id', station_id) \
+            .gte('observed_at', start_utc) \
+            .lte('observed_at', end_utc) \
+            .order('observed_at') \
+            .execute()
+
+        if not result.data:
+            return {"error": f"{year}년 {month}월 데이터가 없습니다."}
+
+        df = pd.DataFrame(result.data)
+        df['observed_at'] = pd.to_datetime(df['observed_at']).dt.tz_convert('Asia/Seoul')
+        df['tide_level'] = pd.to_numeric(df['tide_level'])
+
+        highest = df.loc[df['tide_level'].idxmax()]
+        lowest = df.loc[df['tide_level'].idxmin()]
+        avg_tide = df['tide_level'].mean()
+
+        df['date'] = df['observed_at'].dt.date
+        daily_range = df.groupby('date')['tide_level'].apply(lambda x: x.max() - x.min())
+        avg_range = daily_range.mean()
+
+        summary = {
+            "최고 조위": f"{highest['tide_level']:.1f}cm ({highest['observed_at'].strftime('%Y-%m-%d %H:%M')})",
+            "최저 조위": f"{lowest['tide_level']:.1f}cm ({lowest['observed_at'].strftime('%Y-%m-%d %H:%M')})",
+            "평균 조위": f"{avg_tide:.1f}cm",
+            "평균 조차": f"{avg_range:.1f}cm"
+        }
+
+        fig = make_subplots(rows=2, cols=1, subplot_titles=("일별 조위 변화", "일별 조차"))
+        fig.add_trace(go.Box(x=df['observed_at'].dt.strftime('%Y-%m-%d'), y=df['tide_level'], name='조위'), row=1, col=1)
+        fig.add_trace(go.Bar(x=daily_range.index.strftime('%Y-%m-%d'), y=daily_range.values, name='조차'), row=2, col=1)
+        fig.update_layout(height=700, title_text=f"{STATION_NAMES.get(station_id, station_id)} - {year}년 {month}월 요약")
+
+        return summary, fig
+
+    except Exception as e:
+        return {"error": f"월간 요약 생성 중 오류 발생: {e}"}, None

app.py

@@ -1,1157 +1,23 @@
-import gradio as gr
-import subprocess
-import json
-import os
-import numpy as np
-import pandas as pd
-import plotly.graph_objects as go
-from plotly.subplots import make_subplots
-import plotly.express as px
-from datetime import datetime, timedelta
-import pytz
-from dateutil import parser as date_parser
 import warnings
-import traceback
+from dotenv import load_dotenv
 
-# Supabase 연동 추가
-try:
-    from supabase import create_client, Client
-    SUPABASE_AVAILABLE = True
-except ImportError:
-    SUPABASE_AVAILABLE = False
-    print("Supabase 패키지가 설치되지 않았습니다.")
-    
-# Gemini 연동 확인
-try:
-    import google.generativeai as genai
-    GEMINI_AVAILABLE = True
-except ImportError:
-    GEMINI_AVAILABLE = False
-    print("Gemini (google-generativeai) 패키지가 설치되지 않았습니다.")
-
-warnings.filterwarnings('ignore')
-
-# --- 0. 설정 ---
-SUPABASE_URL = os.environ.get("SUPABASE_URL")
-SUPABASE_KEY = os.environ.get("SUPABASE_KEY")  # SUPABASE_ANON_KEY를 SUPABASE_KEY로 통일
-GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY")
-
-STATIONS = [
-    "DT_0001", "DT_0065", "DT_0008", "DT_0067", "DT_0043", "DT_0002",
-    "DT_0050", "DT_0017", "DT_0052", "DT_0025", "DT_0051", "DT_0037",
-    "DT_0024", "DT_0018", "DT_0068", "DT_0003", "DT_0066"
-]
-
-STATION_NAMES = {
-    "DT_0001": "인천", "DT_0002": "평택", "DT_0003": "영광", "DT_0008": "안산",
-    "DT_0017": "대산", "DT_0018": "군산", "DT_0024": "장항", "DT_0025": "보령",
-    "DT_0037": "어청도", "DT_0043": "영흥도", "DT_0050": "태안", "DT_0051": "서천마량",
-    "DT_0052": "인천송도", "DT_0065": "덕적도", "DT_0066": "향화도", "DT_0067": "안흥",
-    "DT_0068": "위도"
-}
-
-# --- 1. 유틸리티 함수들 ---
-def clean_string(s):
-    """문자열에서 특수 유니코드 문자 제거"""
-    if s is None:
-        return None
-    cleaned = s.replace('\u2028', '').replace('\u2029', '')
-    import re
-    cleaned = re.sub(r'[\x00-\x1f\x7f-\x9f]', '', cleaned)
-    return cleaned.strip()
-
-def get_supabase_client():
-    """Supabase 클라이언트 생성"""
-    if not SUPABASE_AVAILABLE:
-        return None
-    
-    try:
-        url = os.getenv("SUPABASE_URL")
-        key = os.getenv("SUPABASE_KEY")
-        
-        if not url or not key:
-            print("Supabase 환경변수가 설정되지 않았습니다.")
-            return None
-        
-        url = clean_string(url)
-        key = clean_string(key)
-        
-        if not url.startswith('http'):
-            print(f"잘못된 SUPABASE_URL 형식: {url}")
-            return None
-            
-        return create_client(url, key)
-    except Exception as e:
-        print(f"Supabase 연결 오류: {e}")
-        import traceback
-        traceback.print_exc()
-        return None
-
-# --- 2. 예측 관련 함수들 ---
-def get_harmonic_predictions(station_id, start_time, end_time):
-    """해당 시간 범위의 조화 예측값 조회"""
-    supabase = get_supabase_client()
-    if not supabase:
-        print("Supabase 클라이언트를 생성할 수 없습니다.")
-        return []
-    
-    try:
-        import pytz
-        kst = pytz.timezone('Asia/Seoul')
-        
-        if start_time.tzinfo is None:
-            start_time = kst.localize(start_time)
-        if end_time.tzinfo is None:
-            end_time = kst.localize(end_time)
-            
-        start_utc = start_time.astimezone(pytz.UTC)
-        end_utc = end_time.astimezone(pytz.UTC)
-        
-        start_str = start_utc.strftime('%Y-%m-%dT%H:%M:%S+00:00')
-        end_str = end_utc.strftime('%Y-%m-%dT%H:%M:%S+00:00')
-        
-        print(f"조화 예측 조회: {station_id}")
-        print(f"  KST 시간: {start_time.strftime('%Y-%m-%d %H:%M')} ~ {end_time.strftime('%Y-%m-%d %H:%M')}")
-        print(f"  UTC 시간: {start_str} ~ {end_str}")
-        
-        result = supabase.table('harmonic_predictions')\
-            .select('predicted_at, harmonic_level')\
-            .eq('station_id', station_id)\
-            .gte('predicted_at', start_str)\
-            .lte('predicted_at', end_str)\
-            .order('predicted_at')\
-            .limit(1000)\
-            .execute()
-        
-        if result.data:
-            print(f"조화 예측 데이터 {len(result.data)}개 조회 성공")
-            for i, item in enumerate(result.data[:3]):
-                print(f"  샘플 {i+1}: {item['predicted_at']}, {item['harmonic_level']:.2f}cm")
-        else:
-            print("조화 예측 데이터가 없습니다.")
-            check_result = supabase.table('harmonic_predictions')\
-                .select('predicted_at')\
-                .eq('station_id', station_id)\
-                .order('predicted_at')\
-                .limit(1)\
-                .execute()
-            
-            if check_result.data:
-                print(f"  해당 관측소의 가장 빠른 예측 시간: {check_result.data[0]['predicted_at']}")
-        
-        return result.data if result.data else []
-    except Exception as e:
-        print(f"조화 예측값 조회 오류: {e}")
-        traceback.print_exc()
-        return []
+# Load environment variables from .env file
+load_dotenv()
 
-def calculate_final_tide(residual_predictions, station_id, last_time):
-    """잔차 예측 + 조화 예측 = 최종 조위 계산"""
-    if isinstance(last_time, pd.Timestamp):
-        last_time = last_time.to_pydatetime()
-    
-    import pytz
-    kst = pytz.timezone('Asia/Seoul')
-    if last_time.tzinfo is None:
-        last_time = kst.localize(last_time)
-    
-    start_time = last_time + timedelta(minutes=5)
-    end_time = last_time + timedelta(minutes=72*5)
-    
-    harmonic_data = get_harmonic_predictions(station_id, start_time, end_time)
-    
-    residual_flat = residual_predictions.flatten()
-    num_points = len(residual_flat)
-    
-    if not harmonic_data:
-        print("조화 예측 데이터를 찾을 수 없습니다. 잔차 예측만 반환합니다.")
-        return {
-            'times': [last_time + timedelta(minutes=(i+1)*5) for i in range(num_points)],
-            'residual': residual_flat.tolist(),
-            'harmonic': [0.0] * num_points,
-            'final_tide': residual_flat.tolist()
-        }
-    
-    final_results = {
-        'times': [],
-        'residual': [],
-        'harmonic': [],
-        'final_tide': []
-    }
-    
-    harmonic_dict = {}
-    for h_data in harmonic_data:
-        h_time_str = h_data['predicted_at']
-        
-        try:
-            if 'T' in h_time_str:
-                if h_time_str.endswith('Z'):
-                    h_time = datetime.fromisoformat(h_time_str[:-1] + '+00:00')
-                elif '+' in h_time_str or '-' in h_time_str[-6:]:
-                    h_time = datetime.fromisoformat(h_time_str)
-                else:
-                    h_time = datetime.fromisoformat(h_time_str + '+00:00')
-            else:
-                from dateutil import parser
-                h_time = parser.parse(h_time_str)
-            
-            if h_time.tzinfo is None:
-                h_time = pytz.UTC.localize(h_time)
-            h_time = h_time.astimezone(kst)
-            
-        except Exception as e:
-            print(f"시간 파싱 오류: {h_time_str}, {e}")
-            continue
-        
-        minutes = (h_time.minute // 5) * 5
-        h_time = h_time.replace(minute=minutes, second=0, microsecond=0)
-        harmonic_value = float(h_data['harmonic_level'])
-        harmonic_dict[h_time] = harmonic_value
-    
-    for i, residual in enumerate(residual_flat):
-        pred_time = last_time + timedelta(minutes=(i+1)*5)
-        pred_time = pred_time.replace(second=0, microsecond=0)
-        
-        harmonic_value = harmonic_dict.get(pred_time, 0.0)
-        
-        if harmonic_value == 0.0 and harmonic_dict:
-            min_diff = float('inf')
-            for h_time, h_val in harmonic_dict.items():
-                diff = abs((h_time - pred_time).total_seconds())
-                if diff < min_diff and diff < 300:
-                    min_diff = diff
-                    harmonic_value = h_val
-        
-        final_tide = float(residual) + harmonic_value
-        
-        final_results['times'].append(pred_time)
-        final_results['residual'].append(float(residual))
-        final_results['harmonic'].append(harmonic_value)
-        final_results['final_tide'].append(final_tide)
-    
-    print(f"최종 조위 계산 완료: {len(final_results['times'])}개 포인트")
-    return final_results
-
-def save_predictions_to_supabase(station_id, prediction_results):
-    """예측 결과를 Supabase에 저장"""
-    supabase = get_supabase_client()
-    if not supabase:
-        print("Supabase 클라이언트를 생성할 수 없습니다.")
-        return 0
-    
-    try:
-        if prediction_results['times']:
-            start_time = prediction_results['times'][0].strftime('%Y-%m-%dT%H:%M:%S')
-            end_time = prediction_results['times'][-1].strftime('%Y-%m-%dT%H:%M:%S')
-            
-            supabase.table('tide_predictions')\
-                .delete()\
-                .eq('station_id', station_id)\
-                .gte('predicted_at', start_time)\
-                .lte('predicted_at', end_time)\
-                .execute()
-        
-        insert_data = []
-        for i in range(len(prediction_results['times'])):
-            time_str = prediction_results['times'][i].strftime('%Y-%m-%dT%H:%M:%S')
-            
-            insert_data.append({
-                'station_id': station_id,
-                'predicted_at': time_str,
-                'predicted_residual': float(prediction_results['residual'][i]),
-                'harmonic_level': float(prediction_results['harmonic'][i]),
-                'final_tide_level': float(prediction_results['final_tide'][i])
-            })
-        
-        result = supabase.table('tide_predictions')\
-            .insert(insert_data)\
-            .execute()
-        
-        return len(insert_data)
-    except Exception as e:
-        print(f"예측 결과 저장 오류: {e}")
-        traceback.print_exc()
-        return 0
-
-def get_common_args(station_id):
-    return [
-        "--model", "TimeXer", "--features", "MS", "--seq_len", "144", "--pred_len", "72",
-        "--label_len", "96", "--enc_in", "5", "--dec_in", "5", "--c_out", "1",
-        "--d_model", "256", "--d_ff", "512", "--n_heads", "8", "--e_layers", "1",
-        "--d_layers", "1", "--factor", "3", "--patch_len", "16", "--expand", "2", "--d_conv", "4"
-    ]
-
-def validate_csv_file(file_path, required_rows=144):
-    """CSV 파일 유효성 검사"""
-    try:
-        df = pd.read_csv(file_path)
-        required_columns = ['date', 'air_pres', 'wind_dir', 'wind_speed', 'air_temp', 'residual']
-        missing_columns = [col for col in required_columns if col not in df.columns]
-        
-        if missing_columns:
-            return False, f"필수 컬럼이 누락되었습니다: {missing_columns}"
-        
-        if len(df) < required_rows:
-            return False, f"데이터가 부족합니다. 최소 {required_rows}행 필요, 현재 {len(df)}행"
-            
-        return True, "파일이 유효합니다."
-    except Exception as e:
-        return False, f"파일 읽기 오류: {str(e)}"
-
-def execute_inference_and_get_results(command):
-    """inference 실행하고 결과 파일을 읽어서 반환"""
-    try:
-        print(f"실행 명령어: {' '.join(command)}")
-        result = subprocess.run(command, capture_output=True, text=True, timeout=300)
-
-        if result.returncode != 0:
-            error_message = (
-                f"실행 실패 (Exit Code: {result.returncode}):\n\n"
-                f"--- 에러 로그 ---\n{result.stderr}\n\n"
-                f"--- 일반 출력 ---\n{result.stdout}"
-            )
-            raise gr.Error(error_message)
-        
-        return True, result.stdout
-    except subprocess.TimeoutExpired:
-        raise gr.Error("실행 시간이 초과되었습니다. (5분 제한)")
-    except Exception as e:
-        raise gr.Error(f"내부 오류: {str(e)}")
-
-def create_enhanced_prediction_plot(prediction_results, input_data, station_name):
-    """잔차 + 조화 + 최종 조위를 모두 표시하는 향상된 플롯"""
-    try:
-        input_df = pd.read_csv(input_data.name)
-        input_df['date'] = pd.to_datetime(input_df['date'])
-        
-        recent_data = input_df.tail(24)
-        future_times = pd.to_datetime(prediction_results['times'])
-        
-        fig = go.Figure()
-        
-        fig.add_trace(go.Scatter(
-            x=recent_data['date'],
-            y=recent_data['residual'],
-            mode='lines+markers',
-            name='실제 잔차조위',
-            line=dict(color='blue', width=2),
-            marker=dict(size=4)
-        ))
-        
-        fig.add_trace(go.Scatter(
-            x=future_times,
-            y=prediction_results['residual'],
-            mode='lines+markers',
-            name='잔차 예측',
-            line=dict(color='red', width=2, dash='dash'),
-            marker=dict(size=3)
-        ))
-        
-        if any(h != 0 for h in prediction_results['harmonic']):
-            fig.add_trace(go.Scatter(
-                x=future_times,
-                y=prediction_results['harmonic'],
-                mode='lines',
-                name='조화 예측',
-                line=dict(color='orange', width=2)
-            ))
-            
-            fig.add_trace(go.Scatter(
-                x=future_times,
-                y=prediction_results['final_tide'],
-                mode='lines+markers',
-                name='최종 조위',
-                line=dict(color='green', width=3),
-                marker=dict(size=4)
-            ))
-        
-        last_time = recent_data['date'].iloc[-1]
-        
-        fig.add_annotation(
-            x=last_time,
-            y=0,
-            text="← 과거 | 미래 →",
-            showarrow=False,
-            yref="paper",
-            yshift=10,
-            font=dict(size=12, color="gray")
-        )
-        
-        fig.update_layout(
-            title=f'{station_name} 통합 조위 예측 결과',
-            xaxis_title='시간',
-            yaxis_title='수위 (cm)',
-            hovermode='x unified',
-            height=600,
-            showlegend=True,
-            xaxis=dict(tickformat='%H:%M<br>%m/%d', gridcolor='lightgray', showgrid=True),
-            yaxis=dict(gridcolor='lightgray', showgrid=True),
-            plot_bgcolor='white'
-        )
-        
-        return fig
-    except Exception as e:
-        print(f"Enhanced plot creation error: {e}")
-        traceback.print_exc()
-        fig = go.Figure()
-        fig.add_annotation(
-            text=f"시각화 생성 중 오류: {str(e)}",
-            xref="paper", yref="paper",
-            x=0.5, y=0.5, showarrow=False
-        )
-        return fig
-
-def single_prediction(station_id, input_csv_file):
-    if input_csv_file is None: 
-        raise gr.Error("예측을 위한 입력 파일을 업로드해��세요.")
-    
-    is_valid, message = validate_csv_file(input_csv_file.name)
-    if not is_valid:
-        raise gr.Error(f"파일 오류: {message}")
-    
-    station_name = STATION_NAMES.get(station_id, station_id)
-    
-    common_args = get_common_args(station_id)
-    setting_name = f"long_term_forecast_{station_id}_144_72_TimeXer_TIDE_ftMS_sl144_ll96_pl72_dm256_nh8_el1_dl1_df512_expand2_dc4_fc3_ebtimeF_dtTrue_Exp_0"
-    checkpoint_path = f"./checkpoints/{setting_name}/checkpoint.pth"
-    scaler_path = f"./checkpoints/{setting_name}/scaler.gz"
-    
-    if not os.path.exists(checkpoint_path):
-        raise gr.Error(f"모델 파일을 찾을 수 없습니다: {checkpoint_path}")
-    if not os.path.exists(scaler_path):
-        raise gr.Error(f"스케일러 파일을 찾을 수 없습니다: {scaler_path}")
-    
-    command = ["python", "inference.py", 
-               "--checkpoint_path", checkpoint_path, 
-               "--scaler_path", scaler_path, 
-               "--predict_input_file", input_csv_file.name] + common_args
-    
-    gr.Info(f"{station_name}({station_id}) 통합 조위 예측을 실행중입니다...")
-    
-    success, output = execute_inference_and_get_results(command)
-    
-    try:
-        prediction_file = "pred_results/prediction_future.npy"
-        if os.path.exists(prediction_file):
-            residual_predictions = np.load(prediction_file)
-            
-            input_df = pd.read_csv(input_csv_file.name)
-            input_df['date'] = pd.to_datetime(input_df['date'])
-            last_time = input_df['date'].iloc[-1]
-            
-            prediction_results = calculate_final_tide(residual_predictions, station_id, last_time)
-            plot = create_enhanced_prediction_plot(prediction_results, input_csv_file, station_name)
-            
-            has_harmonic = any(h != 0 for h in prediction_results['harmonic'])
-            
-            if has_harmonic:
-                result_df = pd.DataFrame({
-                    '예측 시간': [t.strftime('%Y-%m-%d %H:%M') for t in prediction_results['times']],
-                    '잔차 예측 (cm)': [f"{val:.2f}" for val in prediction_results['residual']],
-                    '조화 예측 (cm)': [f"{val:.2f}" for val in prediction_results['harmonic']],
-                    '최종 조위 (cm)': [f"{val:.2f}" for val in prediction_results['final_tide']]
-                })
-            else:
-                result_df = pd.DataFrame({
-                    '예측 시간': [t.strftime('%Y-%m-%d %H:%M') for t in prediction_results['times']],
-                    '잔차 예측 (cm)': [f"{val:.2f}" for val in prediction_results['residual']]
-                })
-            
-            saved_count = save_predictions_to_supabase(station_id, prediction_results)
-            if saved_count > 0:
-                save_message = f"\n💾 Supabase에 {saved_count}개 예측 결과 저장 완료!"
-            elif get_supabase_client() is None:
-                save_message = "\n⚠️ Supabase 연결 실패 (환경변수 확인 필요)"
-            else:
-                save_message = "\n⚠️ Supabase 저장 실패"
-            
-            return plot, result_df, f"✅ 예측 완료!{save_message}\n\n{output}"
-        else:
-            return None, None, f"❌ 결과 파일을 찾을 수 없습니다.\n\n{output}"
-    except Exception as e:
-        print(f"Result processing error: {e}")
-        traceback.print_exc()
-        return None, None, f"❌ 결과 처리 중 오류: {str(e)}\n\n{output}"
-
-# --- 3. Gemini 챗봇 관련 함수들 ---
-def parse_intent_with_llm(message: str) -> dict:
-    """LLM을 사용해 사용자 질문에서 의도를 분석하고 JSON으로 반환"""
-    if not GEMINI_API_KEY: 
-        return {"error": "Gemini API 키가 설정되지 않았습니다."}
-    
-    prompt = f"""
-    당신은 사용자의 자연어 질문을 분석하여 JSON 객체로 변환하는 전문가입니다.
-    질문에서 '관측소 이름', '원하는 정보', '시작 시간', '종료 시간'을 추출해주세요.
-    현재 시간은 {datetime.now(pytz.timezone('Asia/Seoul')).strftime('%Y-%m-%d %H:%M:%S')} KST 입니다.
+# Import handlers and UI creator from modules
+from prediction import single_prediction
+from chatbot import process_chatbot_query_with_llm
+from ui import create_ui
 
-    - '원하는 정보'는 '특정 시간 조위' 또는 '구간 조위' 중 하나여야 합니다.
-    - '시작 시간'과 '종료 시간'은 'YYYY-MM-DD HH:MM:SS' 형식으로 변환해주세요.
-    - 단일 시간이면 시작과 종료 시간을 동일하게 설정하고, 구간이면 그에 맞게 설정하세요.
-    - 관측소 이름이 없으면 '인천'을 기본값으로 사용하세요.
-
-    [사용자 질문]: {message}
-    [JSON 출력]:
-    """
-    try:
-        genai.configure(api_key=GEMINI_API_KEY)
-        model = genai.GenerativeModel('gemini-1.5-flash', generation_config={"response_mime_type": "application/json"})
-        response = model.generate_content(prompt)
-        return json.loads(response.text)
-    except Exception as e:
-        return {"error": f"LLM 의도 분석 중 오류 발생: {e}"}
-
-def retrieve_context_from_db(intent: dict) -> str:
-    """분석된 의도를 바탕으로 데이터베이스에서 정보 검색"""
-    supabase = get_supabase_client()
-    if not supabase: 
-        return "데이터베이스에 연결할 수 없습니다."
-
-    if "error" in intent:
-        return f"의도 분석에 실패했습니다: {intent['error']}"
-    
-    station_name = intent.get("관측소 이름", "인천")
-    start_time_str = intent.get("시작 시간")
-    end_time_str = intent.get("종료 시간")
-    
-    station_id = next((sid for sid, name in STATION_NAMES.items() if name == station_name), "DT_0001")
-
-    if not start_time_str or not end_time_str:
-        return "질문에서 시간 정보를 찾을 수 없습니다."
-
-    try:
-        start_time = date_parser.parse(start_time_str)
-        end_time = date_parser.parse(end_time_str)
-
-        start_query_str = start_time.strftime('%Y-%m-%d %H:%M:%S')
-        end_query_str = end_time.strftime('%Y-%m-%d %H:%M:%S')
-        
-        print(f"'{station_id}'의 최종 예측 테이블 조회 중...")
-        print(f"조회 시간 범위 (KST): {start_query_str} ~ {end_query_str}")
-        
-        result = supabase.table('tide_predictions')\
-            .select('*')\
-            .eq('station_id', station_id)\
-            .gte('predicted_at', start_query_str)\
-            .lte('predicted_at', end_query_str)\
-            .order('predicted_at')\
-            .execute()
-
-        if result.data:
-            kst = pytz.timezone('Asia/Seoul')
-            info_text = f"'{station_name}'의 '{start_time_str}'부터 '{end_time_str}'까지 조위 정보입니다.\n\n"
-            
-            if len(result.data) > 10:
-                levels = [d['final_tide_level'] for d in result.data]
-                max_level = max(levels)
-                min_level = min(levels)
-                info_text += f"- 최고 조위: {max_level:.1f}cm\n- 최저 조위: {min_level:.1f}cm"
-            else:
-                for d in result.data:
-                    time_kst = date_parser.parse(d['predicted_at']).strftime('%H:%M')
-                    info_text += f"- {time_kst}: 최종 조위 {d['final_tide_level']:.1f}cm (잔차 {d['predicted_residual']:.1f}cm)\n"
-            return info_text
-        else:
-            return "해당 기간의 예측 데이터를 찾을 수 없습니다. '통합 조위 예측' 탭에서 먼저 예측을 실행해주세요."
-
-    except Exception as e:
-        return f"데이터 검색 중 오류 발생: {traceback.format_exc()}"
-
-def process_chatbot_query_with_llm(message: str, history: list) -> str:
-    """최종 RAG 파이프라인"""
-    intent = parse_intent_with_llm(message)
-    retrieved_data = retrieve_context_from_db(intent)
-    
-    prompt = f"""당신은 친절한 해양 조위 정보 전문가입니다. 주어진 [검색된 데이터]를 바탕으로 사용자의 [질문]에 대해 자연스러운 문장으로 답변해주세요.
-    [검색된 데이터]: {retrieved_data}
-    [사용자 질문]: {message}
-    [답변]:"""
-    
-    try:
-        genai.configure(api_key=GEMINI_API_KEY)
-        model = genai.GenerativeModel('gemini-1.5-flash')
-        response = model.generate_content(prompt)
-        return response.text
-    except Exception as e:
-        return f"Gemini 답변 생성 중 오류가 발생했습니다: {e}"
-
-# --- 4. API 함수들 ---
-def api_get_current_tide(station_id):
-    """현재 조위 조회"""
-    supabase = get_supabase_client()
-    if not supabase:
-        return {"error": "Database connection failed"}
-    
-    result = supabase.table('tide_predictions')\
-        .select('*')\
-        .eq('station_id', station_id)\
-        .gte('predicted_at', datetime.now().isoformat())\
-        .order('predicted_at')\
-        .limit(1)\
-        .execute()
-    
-    if result.data:
-        data = result.data[0]
-        return {
-            "station_id": station_id,
-            "time": data['predicted_at'],
-            "tide_level": data.get('final_tide_level', 0),
-            "residual": data.get('predicted_residual', 0),
-            "harmonic": data.get('harmonic_level', 0)
-        }
-    return {"error": "No data found"}
-
-def api_get_extremes(station_id, hours=24):
-    """만조/간조 시간 조회"""
-    supabase = get_supabase_client()
-    if not supabase:
-        return {"error": "Database connection failed"}
-    
-    end_time = datetime.now() + timedelta(hours=hours)
-    
-    result = supabase.table('tide_predictions')\
-        .select('predicted_at, final_tide_level')\
-        .eq('station_id', station_id)\
-        .gte('predicted_at', datetime.now().isoformat())\
-        .lte('predicted_at', end_time.isoformat())\
-        .order('predicted_at')\
-        .execute()
-    
-    if not result.data:
-        return {"error": "No data found"}
-    
-    extremes = []
-    data = result.data
-    
-    for i in range(1, len(data) - 1):
-        prev_level = data[i-1]['final_tide_level']
-        curr_level = data[i]['final_tide_level']
-        next_level = data[i+1]['final_tide_level']
-        
-        if curr_level > prev_level and curr_level > next_level:
-            extremes.append({
-                'type': 'high',
-                'time': data[i]['predicted_at'],
-                'level': curr_level
-            })
-        elif curr_level < prev_level and curr_level < next_level:
-            extremes.append({
-                'type': 'low',
-                'time': data[i]['predicted_at'],
-                'level': curr_level
-            })
-    
-    return {
-        "station_id": station_id,
-        "hours": hours,
-        "count": len(extremes),
-        "extremes": extremes
-    }
-def api_get_historical_tide(station_id, date_str, hours=24):
-    """과거 특정 날짜의 조위 데이터 조회"""
-    supabase = get_supabase_client()
-    if not supabase:
-        return {"error": "Database connection failed"}
-    
-    try:
-        # 날짜 파싱 (YYYY-MM-DD 형식)
-        start_date = datetime.strptime(date_str, "%Y-%m-%d")
-        end_date = start_date + timedelta(hours=hours)
-        
-        # 과거 예측 데이터 조회
-        result = supabase.table('tide_predictions')\
-            .select('predicted_at, final_tide_level, harmonic_level, predicted_residual')\
-            .eq('station_id', station_id)\
-            .gte('predicted_at', start_date.isoformat())\
-            .lte('predicted_at', end_date.isoformat())\
-            .order('predicted_at')\
-            .execute()
-        
-        if result.data:
-            # 통계 계산
-            levels = [d['final_tide_level'] for d in result.data]
-            
-            return {
-                "station_id": station_id,
-                "date": date_str,
-                "hours": hours,
-                "count": len(result.data),
-                "statistics": {
-                    "max": max(levels),
-                    "min": min(levels),
-                    "avg": sum(levels) / len(levels)
-                },
-                "data": result.data[:100]  # 최대 100개만 반환
-            }
-        
-        # 예측 데이터가 없으면 관측 데이터 확인
-        result = supabase.table('tide_observations')\
-            .select('observed_at, residual, air_pres, wind_speed, air_temp')\
-            .eq('station_id', station_id)\
-            .gte('observed_at', start_date.isoformat())\
-            .lte('observed_at', end_date.isoformat())\
-            .order('observed_at')\
-            .execute()
-        
-        if result.data:
-            return {
-                "station_id": station_id,
-                "date": date_str,
-                "type": "observation",  # 관측 데이터임을 표시
-                "count": len(result.data),
-                "data": result.data[:100]
-            }
-        
-        return {"error": "No historical data found for this date"}
-        
-    except Exception as e:
-        return {"error": f"Date parsing error: {str(e)}"}
-
-def api_get_historical_extremes(station_id, date_str):
-    """과거 특정 날짜의 만조/간조 정보"""
-    supabase = get_supabase_client()
-    if not supabase:
-        return {"error": "Database connection failed"}
-    
-    try:
-        # 하루 전체 데이터
-        start_date = datetime.strptime(date_str, "%Y-%m-%d")
-        end_date = start_date + timedelta(days=1)
-        
-        result = supabase.table('tide_predictions')\
-            .select('predicted_at, final_tide_level')\
-            .eq('station_id', station_id)\
-            .gte('predicted_at', start_date.isoformat())\
-            .lt('predicted_at', end_date.isoformat())\
-            .order('predicted_at')\
-            .execute()
-        
-        if not result.data or len(result.data) < 3:
-            return {"error": "Insufficient data for this date"}
-        
-        # 극값 찾기
-        extremes = []
-        data = result.data
-        
-        for i in range(1, len(data) - 1):
-            prev_level = data[i-1]['final_tide_level']
-            curr_level = data[i]['final_tide_level']
-            next_level = data[i+1]['final_tide_level']
-            
-            if curr_level > prev_level and curr_level > next_level:
-                extremes.append({
-                    'type': 'high',
-                    'time': data[i]['predicted_at'],
-                    'level': curr_level
-                })
-            elif curr_level < prev_level and curr_level < next_level:
-                extremes.append({
-                    'type': 'low',
-                    'time': data[i]['predicted_at'],
-                    'level': curr_level
-                })
-        
-        # 최고/최저 찾기
-        all_levels = [d['final_tide_level'] for d in data]
-        daily_max = max(all_levels)
-        daily_min = min(all_levels)
-        
-        return {
-            "station_id": station_id,
-            "date": date_str,
-            "daily_max": daily_max,
-            "daily_min": daily_min,
-            "daily_range": daily_max - daily_min,
-            "extremes": extremes,
-            "high_tide_count": len([e for e in extremes if e['type'] == 'high']),
-            "low_tide_count": len([e for e in extremes if e['type'] == 'low'])
-        }
-        
-    except Exception as e:
-        return {"error": f"Error: {str(e)}"}
-
-def api_compare_dates(station_id, date1, date2):
-    """두 날짜의 조위 패턴 비교"""
-    supabase = get_supabase_client()
-    if not supabase:
-        return {"error": "Database connection failed"}
-    
-    try:
-        results = {}
-        
-        for date_str in [date1, date2]:
-            start_date = datetime.strptime(date_str, "%Y-%m-%d")
-            end_date = start_date + timedelta(days=1)
-            
-            result = supabase.table('tide_predictions')\
-                .select('predicted_at, final_tide_level')\
-                .eq('station_id', station_id)\
-                .gte('predicted_at', start_date.isoformat())\
-                .lt('predicted_at', end_date.isoformat())\
-                .order('predicted_at')\
-                .execute()
-            
-            if result.data:
-                levels = [d['final_tide_level'] for d in result.data]
-                results[date_str] = {
-                    "max": max(levels),
-                    "min": min(levels),
-                    "avg": sum(levels) / len(levels),
-                    "range": max(levels) - min(levels)
-                }
-        
-        if len(results) == 2:
-            # 차이 계산
-            diff = {
-                "max_diff": results[date1]["max"] - results[date2]["max"],
-                "min_diff": results[date1]["min"] - results[date2]["min"],
-                "avg_diff": results[date1]["avg"] - results[date2]["avg"],
-                "range_diff": results[date1]["range"] - results[date2]["range"]
-            }
-            
-            return {
-                "station_id": station_id,
-                "date1": {**{"date": date1}, **results[date1]},
-                "date2": {**{"date": date2}, **results[date2]},
-                "difference": diff
-            }
-        
-        return {"error": "Data not available for both dates"}
-        
-    except Exception as e:
-        return {"error": f"Error: {str(e)}"}
-
-def api_get_monthly_summary(station_id, year, month):
-    """월간 조위 요약 통계"""
-    supabase = get_supabase_client()
-    if not supabase:
-        return {"error": "Database connection failed"}
-    
-    try:
-        # 월 시작/종료 날짜
-        start_date = datetime(year, month, 1)
-        if month == 12:
-            end_date = datetime(year + 1, 1, 1)
-        else:
-            end_date = datetime(year, month + 1, 1)
-        
-        result = supabase.table('tide_predictions')\
-            .select('predicted_at, final_tide_level')\
-            .eq('station_id', station_id)\
-            .gte('predicted_at', start_date.isoformat())\
-            .lt('predicted_at', end_date.isoformat())\
-            .execute()
-        
-        if not result.data:
-            return {"error": "No data for this month"}
-        
-        # 일별 통계 계산
-        daily_stats = {}
-        for item in result.data:
-            date = item['predicted_at'][:10]  # YYYY-MM-DD
-            if date not in daily_stats:
-                daily_stats[date] = []
-            daily_stats[date].append(item['final_tide_level'])
-        
-        # 월간 통계
-        all_levels = [d['final_tide_level'] for d in result.data]
-        monthly_max = max(all_levels)
-        monthly_min = min(all_levels)
-        
-        # 가장 높았던 날과 낮았던 날 찾기
-        highest_day = None
-        lowest_day = None
-        highest_value = 0
-        lowest_value = 9999
-        
-        for date, levels in daily_stats.items():
-            day_max = max(levels)
-            day_min = min(levels)
-            
-            if day_max > highest_value:
-                highest_value = day_max
-                highest_day = date
-            
-            if day_min < lowest_value:
-                lowest_value = day_min
-                lowest_day = date
-        
-        return {
-            "station_id": station_id,
-            "year": year,
-            "month": month,
-            "statistics": {
-                "monthly_max": monthly_max,
-                "monthly_min": monthly_min,
-                "monthly_avg": sum(all_levels) / len(all_levels),
-                "monthly_range": monthly_max - monthly_min,
-                "total_observations": len(result.data),
-                "days_with_data": len(daily_stats)
-            },
-            "extreme_days": {
-                "highest_tide_day": highest_day,
-                "highest_tide_value": highest_value,
-                "lowest_tide_day": lowest_day,
-                "lowest_tide_value": lowest_value
-            }
-        }
-        
-    except Exception as e:
-        return {"error": f"Error: {str(e)}"}
+if __name__ == "__main__":
+    # Suppress warnings for a cleaner output
+    warnings.filterwarnings('ignore')
 
-# --- 5. Gradio 인터페이스 ---
-with gr.Blocks(title="통합 조위 예측 시스템", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🌊 통합 조위 예측 시스템 with Gemini")
-    
-    # 연결 상태 표시
-    client = get_supabase_client()
-    supabase_status = "🟢 연결됨" if client else "🔴 연결 안됨 (환경변수 확인 필요)"
-    gemini_status = "🟢 연결됨" if GEMINI_AVAILABLE and GEMINI_API_KEY else "🔴 연결 안됨 (환경변수 확인 필요)"
-    gr.Markdown(f"**Supabase 상태**: {supabase_status} | **Gemini 상태**: {gemini_status}")
+    # Create the Gradio UI by passing the handlers to the UI generator
+    demo = create_ui(
+        prediction_handler=single_prediction,
+        chatbot_handler=process_chatbot_query_with_llm
+    )
     
-    with gr.Tabs():
-        # 1번 탭: 통합 조위 예측
-        with gr.TabItem("🔮 통합 조위 예측"):
-            gr.Markdown("""
-            ### 🌟 새로운 기능
-            - **잔차 예측**: TimeXer 모델로 기상 영향 예측
-            - **조화 예측**: MATLAB 조화분석으로 천체 영향 예측 (Supabase 연결 시)
-            - **최종 조위**: 잔차 + 조화 = 완전한 조위 예측
-            - **자동 저장**: 예측 결과를 데이터베이스에 자동 저장
-            """)
-            
-            with gr.Row():
-                with gr.Column(scale=1):
-                    station_dropdown1 = gr.Dropdown(
-                        choices=[(f"{STATION_NAMES[s]} ({s})", s) for s in STATIONS], 
-                        label="관측소 선택",
-                        value=STATIONS[0]
-                    )
-                with gr.Column(scale=2):
-                    file_input1 = gr.File(
-                        label="입력 데이터 (.csv 파일)", 
-                        file_types=[".csv"],
-                        file_count="single"
-                    )
-            
-            submit_btn1 = gr.Button("🚀 예측 실행", variant="primary", size="lg")
-            
-            with gr.Row():
-                with gr.Column(scale=2):
-                    plot_output1 = gr.Plot(label="예측 결과 시각화")
-                with gr.Column(scale=1):
-                    table_output1 = gr.Dataframe(
-                        label="예측 결과 테이블"
-                    )
-            
-            text_output1 = gr.Textbox(
-                label="실행 로그", 
-                lines=5, 
-                show_copy_button=True
-            )
-            
-            submit_btn1.click(
-                fn=single_prediction, 
-                inputs=[station_dropdown1, file_input1], 
-                outputs=[plot_output1, table_output1, text_output1]
-            )
-
-        # 2번 탭: AI 조위 챗봇
-        with gr.TabItem("💬 AI 조위 챗봇"):
-            gr.Markdown("""
-            ### 💡 AI 조위 정보 도우미 (Gemini 기반)
-            데이터베이스에 저장된 예측 정보를 바탕으로 AI가 원하는 정보를 찾아옵니다.
-            
-            **질문 예시:**
-            - "현재 인천 조위 알려줘"
-            - "내일 오후 3시 평택 조위는?"
-            - "오늘 만조 시간 알려줘"
-            """)
-            
-            gr.ChatInterface(
-                fn=process_chatbot_query_with_llm,
-                title="",
-                examples=[
-                    "현재 인천 조위 알려줘",
-                    "내일 오후 3시 평택 조위는?",
-                    "오늘 만조 시간 알려줘"
-                ]
-            )
-
-        # 3번 탭: API
-        with gr.TabItem("🔌 API"):
-            gr.Markdown("""
-            ## API 엔드포인트
-            
-            이 앱은 자동으로 API를 제공합니다:
-            
-            ### 사용 가능한 엔드포인트:
-            - `/api/current_tide` - 현재 조위
-            - `/api/extremes` - 만조/간조 시간
-            
-            ### 사용 예시:
-            ```python
-            from gradio_client import Client
-            
-            client = Client("https://your-space.hf.space/")
-            result = client.predict(
-                "DT_0001",
-                api_name="/current_tide"
-            )
-            print(result)
-            ```
-            """)
-            
-            # API 테스트 인터페이스
-            with gr.Row():
-                with gr.Column():
-                    gr.Markdown("### 현재 조위 API 테스트")
-                    api_station_input = gr.Textbox(
-                        label="관측소 ID",
-                        value="DT_0001"
-                    )
-                    api_current_btn = gr.Button("조회")
-                    api_current_output = gr.JSON(label="결과")
-                    
-                    api_current_btn.click(
-                        fn=api_get_current_tide,
-                        inputs=api_station_input,
-                        outputs=api_current_output,
-                        api_name="current_tide"
-                    )
-                
-                with gr.Column():
-                    gr.Markdown("### 만조/간조 API 테스트")
-                    api_extreme_station = gr.Textbox(
-                        label="관측소 ID",
-                        value="DT_0001"
-                    )
-                    api_extreme_hours = gr.Number(
-                        label="시간",
-                        value=24
-                    )
-                    api_extreme_btn = gr.Button("조회")
-                    api_extreme_output = gr.JSON(label="결과")
-                    
-                    api_extreme_btn.click(
-                        fn=api_get_extremes,
-                        inputs=[api_extreme_station, api_extreme_hours],
-                        outputs=api_extreme_output,
-                        api_name="extremes"
-                    )
-        with gr.TabItem("📜 과거 데이터"):
-            gr.Markdown("""
-            ### 과거 조위 데이터 조회
-            특정 날짜의 조위 정보를 확인할 수 있습니다.
-            """)
-        
-            with gr.Row():
-                with gr.Column():
-                    hist_station = gr.Dropdown(
-                        choices=[(f"{STATION_NAMES[s]} ({s})", s) for s in STATIONS],
-                        label="관측소 선택",
-                        value=STATIONS[0]
-                    )
-                    hist_date = gr.Textbox(
-                        label="날짜 (YYYY-MM-DD)",
-                        value=datetime.now().strftime("%Y-%m-%d")
-                    )
-                    hist_hours = gr.Number(
-                        label="조회 시간 (시간)",
-                        value=24,
-                        minimum=1,
-                        maximum=168
-                    )
-                    
-                    hist_btn = gr.Button("조회", variant="primary")
-                    
-                with gr.Column():
-                    hist_output = gr.JSON(label="조회 결과")
-            
-                hist_btn.click(
-                    fn=api_get_historical_tide,
-                    inputs=[hist_station, hist_date, hist_hours],
-                    outputs=hist_output,
-                    api_name="historical_tide"
-                )
-        
-            # 과거 만조/간조
-            with gr.Row():
-                with gr.Column():
-                    gr.Markdown("### 과거 만조/간조 정보")
-                    ext_station = gr.Dropdown(
-                        choices=[(f"{STATION_NAMES[s]} ({s})", s) for s in STATIONS],
-                        label="관측소",
-                        value=STATIONS[0]
-                    )
-                    ext_date = gr.Textbox(
-                        label="날짜 (YYYY-MM-DD)",
-                        value=(datetime.now() - timedelta(days=7)).strftime("%Y-%m-%d")
-                    )
-                    ext_btn = gr.Button("만조/간조 조회")
-                    ext_output = gr.JSON(label="만조/간조 정보")
-                    
-                with gr.Column():
-                    gr.Markdown("### 날짜 비교")
-                    comp_station = gr.Dropdown(
-                        choices=[(f"{STATION_NAMES[s]} ({s})", s) for s in STATIONS],
-                        label="관측소",
-                        value=STATIONS[0]
-                    )
-                    comp_date1 = gr.Textbox(
-                        label="날짜 1",
-                        value=datetime.now().strftime("%Y-%m-%d")
-                    )
-                    comp_date2 = gr.Textbox(
-                        label="날짜 2",
-                        value=(datetime.now() - timedelta(days=7)).strftime("%Y-%m-%d")
-                    )
-                    comp_btn = gr.Button("비교")
-                    comp_output = gr.JSON(label="비교 결과")
-            
-            ext_btn.click(
-                fn=api_get_historical_extremes,
-                inputs=[ext_station, ext_date],
-                outputs=ext_output,
-                api_name="historical_extremes"
-            )
-            
-            comp_btn.click(
-                fn=api_compare_dates,
-                inputs=[comp_station, comp_date1, comp_date2],
-                outputs=comp_output,
-                api_name="compare_dates"
-            )
-        
-            # 월간 요약
-            gr.Markdown("### 월간 요약 통계")
-            with gr.Row():
-                month_station = gr.Dropdown(
-                    choices=[(f"{STATION_NAMES[s]} ({s})", s) for s in STATIONS],
-                    label="관측소",
-                    value=STATIONS[0]
-                )
-                month_year = gr.Number(
-                    label="년도",
-                    value=datetime.now().year,
-                    precision=0
-                )
-                month_month = gr.Number(
-                    label="월",
-                    value=datetime.now().month,
-                    minimum=1,
-                    maximum=12,
-                    precision=0
-                )
-                month_btn = gr.Button("월간 통계 조회")
-            
-            month_output = gr.JSON(label="월간 통계")
-            
-            month_btn.click(
-                fn=api_get_monthly_summary,
-                inputs=[month_station, month_year, month_month],
-                outputs=month_output,
-                api_name="monthly_summary"
-            )
-
-if __name__ == "__main__":
-    demo.launch()
+    # Launch the application
+    demo.launch(share=True)

chatbot.py

@@ -0,0 +1,126 @@
+import os
+import json
+from datetime import datetime
+import pytz
+import traceback
+from dateutil import parser as date_parser
+
+# Local imports
+from supabase_utils import get_supabase_client
+
+# Attempt to import Gemini
+try:
+    import google.generativeai as genai
+    GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+    if GEMINI_API_KEY:
+        genai.configure(api_key=GEMINI_API_KEY)
+        GEMINI_AVAILABLE = True
+    else:
+        GEMINI_AVAILABLE = False
+except ImportError:
+    GEMINI_AVAILABLE = False
+
+# Station names (dependency for retrieve_context_from_db)
+STATION_NAMES = {
+    "DT_0001": "인천", "DT_0065": "평택", "DT_0008": "안산", "DT_0067": "대산",
+    "DT_0043": "보령", "DT_0002": "군산", "DT_0050": "목포", "DT_0017": "제주",
+    "DT_0052": "여수", "DT_0025": "마산", "DT_0051": "부산", "DT_0037": "포항",
+    "DT_0068": "위도"
+}
+
+def parse_intent_with_llm(message: str) -> dict:
+    """LLM을 사용해 사용자 질문에서 의도를 분석하고 JSON으로 반환"""
+    if not GEMINI_AVAILABLE:
+        return {"error": "Gemini API를 사용할 수 없습니다. API 키를 확인하세요."}
+    
+    prompt = f"""
+    당신은 사용자의 자연어 질문을 분석하여 JSON 객체로 변환하는 전문가입니다.
+    질문에서 '관측소 이름', '원하는 정보', '시작 시간', '종료 시간'을 추출해주세요.
+    현재 시간은 {datetime.now(pytz.timezone('Asia/Seoul')).strftime('%Y-%m-%d %H:%M:%S')} KST 입니다.
+
+    - '원하는 정보'는 '특정 시간 조위' 또는 '구간 조위' 중 하나여야 합니다.
+    - '시작 시간'과 '종료 시간'은 'YYYY-MM-DD HH:MM:SS' 형식으로 변환해주세요.
+    - 단일 시간이면 시작과 종료 시간을 동일하게 설정하고, 구간이면 그에 맞게 설정하세요.
+    - 관측소 이름이 없으면 '인천'을 기본값으로 사용하세요.
+
+    [사용자 질문]: {message}
+    [JSON 출력]:
+    """
+    try:
+        model = genai.GenerativeModel('gemini-1.5-flash', generation_config={"response_mime_type": "application/json"})
+        response = model.generate_content(prompt)
+        return json.loads(response.text)
+    except Exception as e:
+        return {"error": f"LLM 의도 분석 중 오류 발생: {e}"} 
+
+def retrieve_context_from_db(intent: dict) -> str:
+    """분석된 의도를 바탕으로 데이터베이스에서 정보 검색"""
+    supabase = get_supabase_client()
+    if not supabase: 
+        return "데이터베이스에 연결할 수 없습니다."
+
+    if "error" in intent:
+        return f"의도 분석에 실패했습니다: {intent['error']}"
+    
+    station_name = intent.get("관측소 이름", "인천")
+    start_time_str = intent.get("시작 시간")
+    end_time_str = intent.get("종료 시간")
+    
+    station_id = next((sid for sid, name in STATION_NAMES.items() if name == station_name), "DT_0001")
+
+    if not start_time_str or not end_time_str:
+        return "질문에서 시간 정보를 찾을 수 없습니다."
+
+    try:
+        start_time = date_parser.parse(start_time_str)
+        end_time = date_parser.parse(end_time_str)
+
+        start_query_str = start_time.strftime('%Y-%m-%d %H:%M:%S')
+        end_query_str = end_time.strftime('%Y-%m-%d %H:%M:%S')
+        
+        result = supabase.table('tide_predictions')\
+            .select('*')\
+            .eq('station_id', station_id)\
+            .gte('predicted_at', start_query_str)\
+            .lte('predicted_at', end_query_str)\
+            .order('predicted_at')\
+            .execute()
+
+        if result.data:
+            info_text = f"'{station_name}'의 '{start_time_str}'부터 '{end_time_str}'까지 조위 정보입니다.\n\n"
+            
+            if len(result.data) > 10:
+                levels = [d['final_tide_level'] for d in result.data]
+                max_level = max(levels)
+                min_level = min(levels)
+                info_text += f"- 최고 조위: {max_level:.1f}cm\n- 최저 조위: {min_level:.1f}cm"
+            else:
+                for d in result.data:
+                    time_kst = date_parser.parse(d['predicted_at']).strftime('%H:%M')
+                    info_text += f"- {time_kst}: 최종 조위 {d['final_tide_level']:.1f}cm (잔차 {d['predicted_residual']:.1f}cm)\n"
+            return info_text
+        else:
+            return "해당 기간의 예측 데이터를 찾을 수 없습니다. '통합 조위 예측' 탭에서 먼저 예측을 실행해주세요."
+
+    except Exception as e:
+        return f"데이터 검색 중 오류 발생: {traceback.format_exc()}"
+
+def process_chatbot_query_with_llm(message: str, history: list) -> str:
+    """최종 RAG 파이프라인"""
+    if not GEMINI_AVAILABLE:
+        return "Gemini API를 사용할 수 없습니다. API 키를 확인하세요."
+        
+    intent = parse_intent_with_llm(message)
+    retrieved_data = retrieve__context_from_db(intent)
+    
+    prompt = f"""당신은 친절한 해양 ��위 정보 전문가입니다. 주어진 [검색된 데이터]를 바탕으로 사용자의 [질문]에 대해 자연스러운 문장으로 답변해주세요.
+    [검색된 데이터]: {retrieved_data}
+    [사용자 질문]: {message}
+    [답변]:"""
+    
+    try:
+        model = genai.GenerativeModel('gemini-1.5-flash')
+        response = model.generate_content(prompt)
+        return response.text
+    except Exception as e:
+        return f"Gemini 답변 생성 중 오류가 발생했습니다: {e}"

chatbot_utils.py

@@ -0,0 +1,114 @@
+import json
+import traceback
+from datetime import datetime
+
+import pytz
+from dateutil import parser as date_parser
+
+from api_utils import api_get_extremes, api_get_current_tide
+from config import GEMINI_API_KEY, STATION_NAMES
+from supabase_utils import get_supabase_client
+
+# Gemini 연동 확인
+try:
+    import google.generativeai as genai
+    GEMINI_AVAILABLE = True
+except ImportError:
+    GEMINI_AVAILABLE = False
+    print("Gemini (google-generativeai) 패키지가 설치되지 않았습니다.")
+
+def parse_intent_with_llm(message: str) -> dict:
+    """LLM을 사용해 사용자 질문에서 의도를 분석하고 JSON으로 반환"""
+    if not GEMINI_API_KEY: 
+        return {"error": "Gemini API 키가 설정되지 않았습니다."}
+    
+    prompt = f"""
+    당신은 사용자의 자연어 질문을 분석하여 JSON 객체로 변환하는 전문가입니다.
+    질문에서 '관측소 이름', '원하는 정보', '시작 시간', '종료 시간'을 추출해주세요.
+    현재 시간은 {datetime.now(pytz.timezone('Asia/Seoul')).strftime('%Y-%m-%d %H:%M:%S')} KST 입니다.
+
+    - '원하는 정보'는 '특정 시간 조위' 또는 '구간 조위' 중 하나여야 합니다.
+    - '시작 시간'과 '종료 시간'은 'YYYY-MM-DD HH:MM:SS' 형식으로 변환해주세요.
+    - 단일 시간이면 시작과 종료 시간을 동일하게 설정하고, 구간이면 그에 맞게 설정하세요.
+    - 관측소 이름이 없으면 '인천'을 기본값으로 사용하세요.
+
+    [사용자 질문]: {message}
+    [JSON 출력]:
+    """
+    try:
+        genai.configure(api_key=GEMINI_API_KEY)
+        model = genai.GenerativeModel('gemini-1.5-flash', generation_config={"response_mime_type": "application/json"})
+        response = model.generate_content(prompt)
+        return json.loads(response.text)
+    except Exception as e:
+        return {"error": f"LLM 의도 분석 중 오류 발생: {e}"}
+
+def retrieve_context_from_db(intent: dict) -> str:
+    """분석된 의도를 바탕으로 데이터베이스에서 정보 검색"""
+    supabase = get_supabase_client()
+    if not supabase: 
+        return "데이터베이스에 연결할 수 없습니다."
+
+    if "error" in intent:
+        return f"의도 분석에 실패했습니다: {intent['error']}"
+    
+    station_name = intent.get("관측소 이름", "인천")
+    start_time_str = intent.get("시작 시간")
+    end_time_str = intent.get("종료 시간")
+    
+    station_id = next((sid for sid, name in STATION_NAMES.items() if name == station_name), "DT_0001")
+
+    if not start_time_str or not end_time_str:
+        return "질문에서 시간 정보를 찾을 수 없습니다."
+
+    try:
+        start_time = date_parser.parse(start_time_str)
+        end_time = date_parser.parse(end_time_str)
+
+        start_query_str = start_time.strftime('%Y-%m-%d %H:%M:%S')
+        end_query_str = end_time.strftime('%Y-%m-%d %H:%M:%S')
+        
+        result = supabase.table('tide_predictions')\
+            .select('*')\
+            .eq('station_id', station_id)\
+            .gte('predicted_at', start_query_str)\
+            .lte('predicted_at', end_query_str)\
+            .order('predicted_at')\
+            .execute()
+
+        if result.data:
+            info_text = f"'{station_name}'의 '{start_time_str}'부터 '{end_time_str}'까지 조위 정보입니다.\n\n"
+            
+            if len(result.data) > 10:
+                levels = [d['final_tide_level'] for d in result.data]
+                max_level = max(levels)
+                min_level = min(levels)
+                info_text += f"- 최고 조위: {max_level:.1f}cm\n- 최저 조위: {min_level:.1f}cm"
+            else:
+                for d in result.data:
+                    time_kst = date_parser.parse(d['predicted_at']).strftime('%H:%M')
+                    info_text += f"- {time_kst}: 최종 조위 {d['final_tide_level']:.1f}cm (잔차 {d['predicted_residual']:.1f}cm)\n"
+            return info_text
+        else:
+            return "해당 기간의 예측 데이터를 찾을 수 없습니다. '통합 조위 예측' 탭에서 먼저 예측을 실행해주세요."
+
+    except Exception as e:
+        return f"데이터 검색 중 오류 발생: {traceback.format_exc()}"
+
+def process_chatbot_query_with_llm(message: str, history: list) -> str:
+    """최종 RAG 파이프라인"""
+    intent = parse_intent_with_llm(message)
+    retrieved_data = retrieve_context_from_db(intent)
+    
+    prompt = f"""당신은 친절한 해양 조위 정보 전문가입니다. 주어진 [검색된 데이터]를 바탕으로 사용자의 [질문]에 대해 자연스러운 문장으로 답변해주세요.
+    [검색된 데이터]: {retrieved_data}
+    [사용자 질문]: {message}
+    [답변]:"""
+    
+    try:
+        genai.configure(api_key=GEMINI_API_KEY)
+        model = genai.GenerativeModel('gemini-1.5-flash')
+        response = model.generate_content(prompt)
+        return response.text
+    except Exception as e:
+        return f"Gemini 답변 생성 중 오류가 발생했습니다: {e}"

config.py

@@ -0,0 +1,20 @@
+import os
+
+# --- 0. 설정 ---
+SUPABASE_URL = os.environ.get("SUPABASE_URL")
+SUPABASE_KEY = os.environ.get("SUPABASE_KEY")
+GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY")
+
+STATIONS = [
+    "DT_0001", "DT_0065", "DT_0008", "DT_0067", "DT_0043", "DT_0002",
+    "DT_0050", "DT_0017", "DT_0052", "DT_0025", "DT_0051", "DT_0037",
+    "DT_0024", "DT_0018", "DT_0068", "DT_0003", "DT_0066"
+]
+
+STATION_NAMES = {
+    "DT_0001": "인천", "DT_0002": "평택", "DT_0003": "영광", "DT_0008": "안산",
+    "DT_0017": "대산", "DT_0018": "군산", "DT_0024": "장항", "DT_0025": "보령",
+    "DT_0037": "어청도", "DT_0043": "영흥도", "DT_0050": "태안", "DT_0051": "서천마량",
+    "DT_0052": "인천송도", "DT_0065": "덕적도", "DT_0066": "향화도", "DT_0067": "안흥",
+    "DT_0068": "위도"
+}

prediction.py

@@ -0,0 +1,300 @@
+import os
+import subprocess
+import traceback
+from datetime import datetime, timedelta
+
+import gradio as gr
+import numpy as np
+import pandas as pd
+import plotly.graph_objects as go
+import pytz
+
+from config import STATION_NAMES
+from supabase_utils import (
+    get_harmonic_predictions, save_predictions_to_supabase, get_supabase_client
+)
+
+def get_common_args(station_id):
+    return [
+        "--model", "TimeXer", "--features", "MS", "--seq_len", "144", "--pred_len", "72",
+        "--label_len", "96", "--enc_in", "5", "--dec_in", "5", "--c_out", "1",
+        "--d_model", "256", "--d_ff", "512", "--n_heads", "8", "--e_layers", "1",
+        "--d_layers", "1", "--factor", "3", "--patch_len", "16", "--expand", "2", "--d_conv", "4"
+    ]
+
+def validate_csv_file(file_path, required_rows=144):
+    """CSV 파일 유효성 검사"""
+    try:
+        df = pd.read_csv(file_path)
+        required_columns = ['date', 'air_pres', 'wind_dir', 'wind_speed', 'air_temp', 'residual']
+        missing_columns = [col for col in required_columns if col not in df.columns]
+        
+        if missing_columns:
+            return False, f"필수 컬럼이 누락되었습니다: {missing_columns}"
+        
+        if len(df) < required_rows:
+            return False, f"데이터가 부족합니다. 최소 {required_rows}행 필요, 현재 {len(df)}행"
+            
+        return True, "파일이 유효합니다."
+    except Exception as e:
+        return False, f"파일 읽기 오류: {str(e)}"
+
+def execute_inference_and_get_results(command):
+    """inference 실행하고 결과 파일을 읽어서 반환"""
+    try:
+        print(f"실행 명령어: {' '.join(command)}")
+        result = subprocess.run(command, capture_output=True, text=True, timeout=300)
+
+        if result.returncode != 0:
+            error_message = (
+                f"실행 실패 (Exit Code: {result.returncode}):\n\n"
+                f"--- 에러 로그 ---\n{result.stderr}\n\n"
+                f"--- 일반 출력 ---\n{result.stdout}"
+            )
+            raise gr.Error(error_message)
+        
+        return True, result.stdout
+    except subprocess.TimeoutExpired:
+        raise gr.Error("실행 시간이 초과되었습니다. (5분 제한)")
+    except Exception as e:
+        raise gr.Error(f"내부 오류: {str(e)}")
+
+def calculate_final_tide(residual_predictions, station_id, last_time):
+    """잔차 예측 + 조화 예측 = 최종 조위 계산"""
+    if isinstance(last_time, pd.Timestamp):
+        last_time = last_time.to_pydatetime()
+    
+    kst = pytz.timezone('Asia/Seoul')
+    if last_time.tzinfo is None:
+        last_time = kst.localize(last_time)
+    
+    start_time = last_time + timedelta(minutes=5)
+    end_time = last_time + timedelta(minutes=72*5)
+    
+    harmonic_data = get_harmonic_predictions(station_id, start_time, end_time)
+    
+    residual_flat = residual_predictions.flatten()
+    num_points = len(residual_flat)
+    
+    if not harmonic_data:
+        print("조화 예측 데이터를 찾을 수 없습니다. 잔차 예측만 반환합니다.")
+        return {
+            'times': [last_time + timedelta(minutes=(i+1)*5) for i in range(num_points)],
+            'residual': residual_flat.tolist(),
+            'harmonic': [0.0] * num_points,
+            'final_tide': residual_flat.tolist()
+        }
+    
+    final_results = {
+        'times': [],
+        'residual': [],
+        'harmonic': [],
+        'final_tide': []
+    }
+    
+    harmonic_dict = {}
+    for h_data in harmonic_data:
+        h_time_str = h_data['predicted_at']
+        
+        try:
+            if 'T' in h_time_str:
+                if h_time_str.endswith('Z'):
+                    h_time = datetime.fromisoformat(h_time_str[:-1] + '+00:00')
+                elif '+' in h_time_str or '-' in h_time_str[-6:]:
+                    h_time = datetime.fromisoformat(h_time_str)
+                else:
+                    h_time = datetime.fromisoformat(h_time_str + '+00:00')
+            else:
+                from dateutil import parser
+                h_time = parser.parse(h_time_str)
+            
+            if h_time.tzinfo is None:
+                h_time = pytz.UTC.localize(h_time)
+            h_time = h_time.astimezone(kst)
+            
+        except Exception as e:
+            print(f"시간 파싱 오류: {h_time_str}, {e}")
+            continue
+        
+        minutes = (h_time.minute // 5) * 5
+        h_time = h_time.replace(minute=minutes, second=0, microsecond=0)
+        harmonic_value = float(h_data['harmonic_level'])
+        harmonic_dict[h_time] = harmonic_value
+    
+    for i, residual in enumerate(residual_flat):
+        pred_time = last_time + timedelta(minutes=(i+1)*5)
+        pred_time = pred_time.replace(second=0, microsecond=0)
+        
+        harmonic_value = harmonic_dict.get(pred_time, 0.0)
+        
+        if harmonic_value == 0.0 and harmonic_dict:
+            min_diff = float('inf')
+            for h_time, h_val in harmonic_dict.items():
+                diff = abs((h_time - pred_time).total_seconds())
+                if diff < min_diff and diff < 300:
+                    min_diff = diff
+                    harmonic_value = h_val
+        
+        final_tide = float(residual) + harmonic_value
+        
+        final_results['times'].append(pred_time)
+        final_results['residual'].append(float(residual))
+        final_results['harmonic'].append(harmonic_value)
+        final_results['final_tide'].append(final_tide)
+    
+    return final_results
+
+def create_enhanced_prediction_plot(prediction_results, input_data, station_name):
+    """잔차 + 조화 + 최종 조위를 모두 표시하는 향상된 플롯"""
+    try:
+        input_df = pd.read_csv(input_data.name)
+        input_df['date'] = pd.to_datetime(input_df['date'])
+        
+        recent_data = input_df.tail(24)
+        future_times = pd.to_datetime(prediction_results['times'])
+        
+        fig = go.Figure()
+        
+        fig.add_trace(go.Scatter(
+            x=recent_data['date'],
+            y=recent_data['residual'],
+            mode='lines+markers',
+            name='실제 잔차조위',
+            line=dict(color='blue', width=2),
+            marker=dict(size=4)
+        ))
+        
+        fig.add_trace(go.Scatter(
+            x=future_times,
+            y=prediction_results['residual'],
+            mode='lines+markers',
+            name='잔차 예측',
+            line=dict(color='red', width=2, dash='dash'),
+            marker=dict(size=3)
+        ))
+        
+        if any(h != 0 for h in prediction_results['harmonic']):
+            fig.add_trace(go.Scatter(
+                x=future_times,
+                y=prediction_results['harmonic'],
+                mode='lines',
+                name='조화 예측',
+                line=dict(color='orange', width=2)
+            ))
+            
+            fig.add_trace(go.Scatter(
+                x=future_times,
+                y=prediction_results['final_tide'],
+                mode='lines+markers',
+                name='최종 조위',
+                line=dict(color='green', width=3),
+                marker=dict(size=4)
+            ))
+        
+        last_time = recent_data['date'].iloc[-1]
+        
+        fig.add_annotation(
+            x=last_time,
+            y=0,
+            text="← 과거 | 미래 →",
+            showarrow=False,
+            yref="paper",
+            yshift=10,
+            font=dict(size=12, color="gray")
+        )
+        
+        fig.update_layout(
+            title=f'{station_name} 통합 조위 예측 결과',
+            xaxis_title='시간',
+            yaxis_title='수위 (cm)',
+            hovermode='x unified',
+            height=600,
+            showlegend=True,
+            xaxis=dict(tickformat='%H:%M<br>%m/%d', gridcolor='lightgray', showgrid=True),
+            yaxis=dict(gridcolor='lightgray', showgrid=True),
+            plot_bgcolor='white'
+        )
+        
+        return fig
+    except Exception as e:
+        print(f"Enhanced plot creation error: {e}")
+        traceback.print_exc()
+        fig = go.Figure()
+        fig.add_annotation(
+            text=f"시각화 생성 중 오류: {str(e)}",
+            xref="paper", yref="paper",
+            x=0.5, y=0.5, showarrow=False
+        )
+        return fig
+
+def single_prediction(station_id, input_csv_file):
+    if input_csv_file is None: 
+        raise gr.Error("예측을 위한 입력 파일을 업로드해주세요.")
+    
+    is_valid, message = validate_csv_file(input_csv_file.name)
+    if not is_valid:
+        raise gr.Error(f"파일 오류: {message}")
+    
+    station_name = STATION_NAMES.get(station_id, station_id)
+    
+    common_args = get_common_args(station_id)
+    setting_name = f"long_term_forecast_{station_id}_144_72_TimeXer_TIDE_ftMS_sl144_ll96_pl72_dm256_nh8_el1_dl1_df512_expand2_dc4_fc3_ebtimeF_dtTrue_Exp_0"
+    checkpoint_path = f"./checkpoints/{setting_name}/checkpoint.pth"
+    scaler_path = f"./checkpoints/{setting_name}/scaler.gz"
+    
+    if not os.path.exists(checkpoint_path):
+        raise gr.Error(f"모델 파일을 찾을 수 없습니다: {checkpoint_path}")
+    if not os.path.exists(scaler_path):
+        raise gr.Error(f"스케일러 파일을 찾을 수 없습니다: {scaler_path}")
+    
+    command = ["python", "inference.py", 
+               "--checkpoint_path", checkpoint_path, 
+               "--scaler_path", scaler_path, 
+               "--predict_input_file", input_csv_file.name] + common_args
+    
+    gr.Info(f"{station_name}({station_id}) 통합 조위 예측을 실행중입니다...")
+    
+    success, output = execute_inference_and_get_results(command)
+    
+    try:
+        prediction_file = "pred_results/prediction_future.npy"
+        if os.path.exists(prediction_file):
+            residual_predictions = np.load(prediction_file)
+            
+            input_df = pd.read_csv(input_csv_file.name)
+            input_df['date'] = pd.to_datetime(input_df['date'])
+            last_time = input_df['date'].iloc[-1]
+            
+            prediction_results = calculate_final_tide(residual_predictions, station_id, last_time)
+            plot = create_enhanced_prediction_plot(prediction_results, input_csv_file, station_name)
+            
+            has_harmonic = any(h != 0 for h in prediction_results['harmonic'])
+            
+            if has_harmonic:
+                result_df = pd.DataFrame({
+                    '예측 시간': [t.strftime('%Y-%m-%d %H:%M') for t in prediction_results['times']],
+                    '잔차 예측 (cm)': [f"{val:.2f}" for val in prediction_results['residual']],
+                    '조화 예측 (cm)': [f"{val:.2f}" for val in prediction_results['harmonic']],
+                    '최종 조위 (cm)': [f"{val:.2f}" for val in prediction_results['final_tide']]
+                })
+            else:
+                result_df = pd.DataFrame({
+                    '예측 시간': [t.strftime('%Y-%m-%d %H:%M') for t in prediction_results['times']],
+                    '잔차 예측 (cm)': [f"{val:.2f}" for val in prediction_results['residual']]
+                })
+            
+            saved_count = save_predictions_to_supabase(station_id, prediction_results)
+            if saved_count > 0:
+                save_message = f"\n💾 Supabase에 {saved_count}개 예측 결과 저장 완료!"
+            elif get_supabase_client() is None:
+                save_message = "\n⚠️ Supabase 연결 실패 (환경변수 확인 필요)"
+            else:
+                save_message = "\n⚠️ Supabase 저장 실패"
+            
+            return plot, result_df, f"✅ 예측 완료!{save_message}\n\n{output}"
+        else:
+            return None, None, f"❌ 결과 파일을 찾을 수 없습니다.\n\n{output}"
+    except Exception as e:
+        print(f"Result processing error: {e}")
+        traceback.print_exc()
+        return None, None, f"❌ 결과 처리 중 오류: {str(e)}\n\n{output}"

supabase_utils.py

@@ -0,0 +1,126 @@
+import os
+import re
+import traceback
+from datetime import datetime
+
+import pandas as pd
+import pytz
+from dateutil import parser as date_parser
+
+from config import SUPABASE_URL, SUPABASE_KEY
+
+# Supabase 연동 추가
+try:
+    from supabase import create_client, Client
+    SUPABASE_AVAILABLE = True
+except ImportError:
+    SUPABASE_AVAILABLE = False
+    print("Supabase 패키지가 설치되지 않았습니다.")
+
+def clean_string(s):
+    """문자열에서 특수 유니코드 문자 제거"""
+    if s is None:
+        return None
+    cleaned = s.replace('\u2028', '').replace('\u2029', '')
+    cleaned = re.sub(r'[\x00-\x1f\x7f-\x9f]', '', cleaned)
+    return cleaned.strip()
+
+def get_supabase_client():
+    """Supabase 클라이언트 생성"""
+    if not SUPABASE_AVAILABLE:
+        return None
+    
+    try:
+        if not SUPABASE_URL or not SUPABASE_KEY:
+            print("Supabase 환경변수가 설정되지 않았습니다.")
+            return None
+        
+        url = clean_string(SUPABASE_URL)
+        key = clean_string(SUPABASE_KEY)
+        
+        if not url.startswith('http'):
+            print(f"잘못된 SUPABASE_URL 형식: {url}")
+            return None
+            
+        return create_client(url, key)
+    except Exception as e:
+        print(f"Supabase 연결 오류: {e}")
+        traceback.print_exc()
+        return None
+
+def get_harmonic_predictions(station_id, start_time, end_time):
+    """해당 시간 범위의 조화 예측값 조회"""
+    supabase = get_supabase_client()
+    if not supabase:
+        print("Supabase 클라이언트를 생성할 수 없습니다.")
+        return []
+    
+    try:
+        kst = pytz.timezone('Asia/Seoul')
+        
+        if start_time.tzinfo is None:
+            start_time = kst.localize(start_time)
+        if end_time.tzinfo is None:
+            end_time = kst.localize(end_time)
+            
+        start_utc = start_time.astimezone(pytz.UTC)
+        end_utc = end_time.astimezone(pytz.UTC)
+        
+        start_str = start_utc.strftime('%Y-%m-%dT%H:%M:%S+00:00')
+        end_str = end_utc.strftime('%Y-%m-%dT%H:%M:%S+00:00')
+        
+        result = supabase.table('harmonic_predictions')\
+            .select('predicted_at, harmonic_level')\
+            .eq('station_id', station_id)\
+            .gte('predicted_at', start_str)\
+            .lte('predicted_at', end_str)\
+            .order('predicted_at')\
+            .limit(1000)\
+            .execute()
+        
+        return result.data if result.data else []
+    except Exception as e:
+        print(f"조화 예측값 조회 오류: {e}")
+        traceback.print_exc()
+        return []
+
+def save_predictions_to_supabase(station_id, prediction_results):
+    """예측 결과를 Supabase에 저장"""
+    supabase = get_supabase_client()
+    if not supabase:
+        print("Supabase 클라이언트를 생성할 수 없습니다.")
+        return 0
+    
+    try:
+        if prediction_results['times']:
+            start_time = prediction_results['times'][0].strftime('%Y-%m-%dT%H:%M:%S')
+            end_time = prediction_results['times'][-1].strftime('%Y-%m-%dT%H:%M:%S')
+            
+            supabase.table('tide_predictions')\
+                .delete()\
+                .eq('station_id', station_id)\
+                .gte('predicted_at', start_time)\
+                .lte('predicted_at', end_time)\
+                .execute()
+        
+        insert_data = []
+        for i in range(len(prediction_results['times'])):
+            time_str = prediction_results['times'][i].strftime('%Y-%m-%dT%H:%M:%S')
+            
+            insert_data.append({
+                'station_id': station_id,
+                'predicted_at': time_str,
+                'predicted_residual': float(prediction_results['residual'][i]),
+                'harmonic_level': float(prediction_results['harmonic'][i]),
+                'final_tide_level': float(prediction_results['final_tide'][i])
+            })
+        
+        result = supabase.table('tide_predictions')\
+            .insert(insert_data)\
+            .execute()
+        
+        return len(insert_data)
+    except Exception as e:
+        print(f"예측 결과 저장 오류: {e}")
+        traceback.print_exc()
+        return 0

ui.py

@@ -0,0 +1,42 @@
+import gradio as gr
+import os
+from config import STATIONS
+from supabase_utils import get_supabase_client
+
+def create_ui(prediction_handler, chatbot_handler):
+    """Gradio UI를 생성하고 반환합니다."""
+    with gr.Blocks(title="통합 조위 예측 시스템", theme=gr.themes.Soft()) as demo:
+        gr.Markdown("# 🌊 통합 조위 예측 시스템 with Gemini")
+
+        # 연결 상태 표시
+        client = get_supabase_client()
+        supabase_status = "🟢 연결됨" if client else "🔴 연결 안됨 (환경변수 확인 필요)"
+        gemini_status = "🟢 연결됨" if os.getenv("GEMINI_API_KEY") else "🔴 연결 안됨 (환경변수 확인 필요)"
+        gr.Markdown(f"**Supabase 상태**: {supabase_status} | **Gemini 상태**: {gemini_status}")
+
+        with gr.Tabs():
+            with gr.TabItem("통합 조위 예측"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        station_id_input = gr.Dropdown(STATIONS, label="관측소 선택", value="DT_0001")
+                        input_csv = gr.File(label="과거 데이터 업로드 (.csv)")
+                        predict_btn = gr.Button("예측 실행", variant="primary")
+                    with gr.Column(scale=3):
+                        output_plot = gr.Plot(label="예측 결과 시각화")
+                        output_df = gr.DataFrame(label="예측 결과 데이터")
+                output_log = gr.Textbox(label="실행 로그", lines=5, interactive=False)
+
+            with gr.TabItem("AI 조위 챗봇"):
+                gr.ChatInterface(
+                    fn=chatbot_handler,
+                    title="AI 조위 챗봇",
+                    description="조위에 대해 궁금한 점을 물어보세요. (예: '인천 오늘 현재 조위 알려줘')",
+                    #examples=[]
+                )
+
+        predict_btn.click(
+            fn=prediction_handler,
+            inputs=[station_id_input, input_csv],
+            outputs=[output_plot, output_df, output_log]
+        )
+    return demo