change the pipeline logic

.github/scripts/demo_controller.py

@@ -0,0 +1,143 @@
+#!/usr/bin/env python3
+"""
+Demo Controller - 시연 시작/중지 제어
+"""
+
+import os
+import sys
+import requests
+import json
+from datetime import datetime
+
+HF_SPACE_URL = os.environ.get('HF_SPACE_URL')
+API_KEY = os.environ.get('INTERNAL_API_KEY')
+
+def call_api(endpoint, data=None, method='POST'):
+    """HF Space API 호출"""
+    url = f"{HF_SPACE_URL}{endpoint}"
+    headers = {
+        'Authorization': f'Bearer {API_KEY}',
+        'Content-Type': 'application/json'
+    }
+    
+    try:
+        if method == 'POST':
+            response = requests.post(url, headers=headers, json=data, timeout=30)
+        else:
+            response = requests.get(url, headers=headers, timeout=30)
+        
+        return response.status_code, response.json()
+    except Exception as e:
+        return 500, {'error': str(e)}
+
+def start_demo():
+    """시연 시작"""
+    print("🚀 Starting interactive demo...")
+    
+    data = {
+        'action': 'start_demo',
+        'timestamp': datetime.now().isoformat(),
+        'demo_mode': 'interactive',
+        'stations': ['DT_0001', 'DT_0002', 'DT_0003', 'DT_0008', 'DT_0017'],
+        'simulation_settings': {
+            'start_time': '2025-07-01T00:00:00',
+            'max_speed': 10,  # 최대 10배속
+            'auto_issues': False  # 자동 문제 발생 비활성화
+        }
+    }
+    
+    status, response = call_api('/api/internal/demo_control', data)
+    
+    if status == 200:
+        print("✅ Demo started successfully")
+        print(f"📊 Session ID: {response.get('session_id', 'N/A')}")
+        print(f"🏪 Active stations: {len(response.get('stations', []))}")
+        print(f"⏰ Simulation start: {response.get('simulation_start_time', 'N/A')}")
+        print(f"🎮 Demo mode: {response.get('demo_mode', 'N/A')}")
+        
+        # 성공 결과를 파일로 저장
+        with open('demo_start_result.json', 'w') as f:
+            json.dump(response, f, indent=2)
+            
+    else:
+        print(f"❌ Failed to start demo: {status}")
+        print(f"Error: {response}")
+        sys.exit(1)
+
+def stop_demo():
+    """시연 중지"""
+    print("🛑 Stopping demo...")
+    
+    data = {
+        'action': 'stop_demo',
+        'timestamp': datetime.now().isoformat(),
+        'save_results': True  # 결과 저장
+    }
+    
+    status, response = call_api('/api/internal/demo_control', data)
+    
+    if status == 200:
+        print("✅ Demo stopped successfully")
+        print(f"⏱️ Session duration: {response.get('duration_minutes', 0)} minutes")
+        print(f"📊 Total data points processed: {response.get('total_processed', 0)}")
+        print(f"🎯 Prediction accuracy: {response.get('final_accuracy', 'N/A')}%")
+        print(f"📈 Average RMSE: {response.get('average_rmse', 'N/A')} cm")
+        
+        # 최종 결과 저장
+        with open('demo_final_results.json', 'w') as f:
+            json.dump(response, f, indent=2)
+            
+    else:
+        print(f"❌ Failed to stop demo: {status}")
+        print(f"Error: {response}")
+
+def get_demo_status():
+    """현재 시연 상태 확인"""
+    print("📊 Checking demo status...")
+    
+    status, response = call_api('/api/internal/demo_status', method='GET')
+    
+    if status == 200:
+        demo_active = response.get('demo_active', False)
+        
+        if demo_active:
+            print("🟢 Demo is currently ACTIVE")
+            print(f"⏰ Running for: {response.get('running_minutes', 0)} minutes")
+            print(f"📊 Current simulation time: {response.get('current_sim_time', 'N/A')}")
+            print(f"🏪 Active stations: {response.get('active_stations', 0)}")
+            print(f"📈 Current RMSE: {response.get('current_rmse', 'N/A')} cm")
+        else:
+            print("🔴 Demo is currently INACTIVE")
+            print(f"🕐 Last session: {response.get('last_session_end', 'Never')}")
+            
+    else:
+        print(f"❌ Failed to get demo status: {status}")
+        print(f"Error: {response}")
+
+if __name__ == '__main__':
+    if len(sys.argv) < 2:
+        print("Usage: python demo_controller.py [start|stop|status]")
+        print("Commands:")
+        print("  start  - Start interactive demo")
+        print("  stop   - Stop current demo")
+        print("  status - Check demo status")
+        sys.exit(1)
+    
+    action = sys.argv[1]
+    
+    if not HF_SPACE_URL or not API_KEY:
+        print("❌ Missing environment variables:")
+        print("   HF_SPACE_URL:", "✓" if HF_SPACE_URL else "✗")
+        print("   INTERNAL_API_KEY:", "✓" if API_KEY else "✗")
+        sys.exit(1)
+    
+    if action == 'start':
+        start_demo()
+    elif action == 'stop':
+        stop_demo()
+    elif action == 'status':
+        get_demo_status()
+    else:
+        print(f"❌ Unknown action: {action}")
+        print("Available actions: start, stop, status")
+        sys.exit(1)

.github/scripts/health_check.py

@@ -0,0 +1,408 @@
+#!/usr/bin/env python3
+"""
+Health Check - 시스템 상태 종합 점검
+"""
+
+import os
+import sys
+import requests
+import json
+import time
+from datetime import datetime, timedelta
+
+HF_SPACE_URL = os.environ.get('HF_SPACE_URL')
+API_KEY = os.environ.get('INTERNAL_API_KEY')
+
+def test_basic_connectivity():
+    """기본 연결성 테스트"""
+    
+    print("🌐 Testing basic connectivity...")
+    
+    try:
+        response = requests.get(f"{HF_SPACE_URL}/api/health", timeout=10)
+        
+        if response.status_code == 200:
+            health_data = response.json()
+            print("   ✅ Basic health endpoint: OK")
+            print(f"   📊 Status: {health_data.get('status', 'unknown')}")
+            print(f"   🕐 Timestamp: {health_data.get('timestamp', 'N/A')}")
+            return True, health_data
+        else:
+            print(f"   ❌ Health endpoint failed: {response.status_code}")
+            return False, None
+            
+    except Exception as e:
+        print(f"   ❌ Connectivity error: {e}")
+        return False, None
+
+def test_api_authentication():
+    """API 인증 테스트"""
+    
+    print("🔐 Testing API authentication...")
+    
+    if not API_KEY:
+        print("   ❌ No API key provided")
+        return False
+    
+    try:
+        response = requests.get(
+            f"{HF_SPACE_URL}/api/internal/demo_status",
+            headers={'Authorization': f'Bearer {API_KEY}'},
+            timeout=10
+        )
+        
+        if response.status_code == 200:
+            print("   ✅ API authentication: OK")
+            return True
+        elif response.status_code == 401:
+            print("   ❌ Authentication failed: Invalid API key")
+            return False
+        else:
+            print(f"   ⚠️ Unexpected response: {response.status_code}")
+            return False
+            
+    except Exception as e:
+        print(f"   ❌ Authentication test error: {e}")
+        return False
+
+def check_demo_status():
+    """시연 상태 확인"""
+    
+    print("🎬 Checking demo status...")
+    
+    try:
+        response = requests.get(
+            f"{HF_SPACE_URL}/api/internal/demo_status",
+            headers={'Authorization': f'Bearer {API_KEY}'},
+            timeout=10
+        )
+        
+        if response.status_code == 200:
+            demo_data = response.json()
+            is_active = demo_data.get('demo_active', False)
+            
+            print(f"   🎭 Demo active: {'✅ YES' if is_active else '🔴 NO'}")
+            
+            if is_active:
+                print(f"   ⏰ Running time: {demo_data.get('running_minutes', 0)} minutes")
+                print(f"   🏪 Active stations: {demo_data.get('active_stations', 0)}")
+                print(f"   📊 Current sim time: {demo_data.get('current_sim_time', 'N/A')}")
+            else:
+                print(f"   🕐 Last session: {demo_data.get('last_session_end', 'Never')}")
+            
+            return True, demo_data
+        else:
+            print(f"   ❌ Demo status check failed: {response.status_code}")
+            return False, None
+            
+    except Exception as e:
+        print(f"   ❌ Demo status error: {e}")
+        return False, None
+
+def check_data_freshness():
+    """데이터 신선도 확인"""
+    
+    print("📊 Checking data freshness...")
+    
+    try:
+        response = requests.get(
+            f"{HF_SPACE_URL}/api/internal/data_freshness",
+            headers={'Authorization': f'Bearer {API_KEY}'},
+            timeout=10
+        )
+        
+        if response.status_code == 200:
+            fresh_data = response.json()
+            oldest_minutes = fresh_data.get('oldest_data_minutes', 0)
+            overall_status = fresh_data.get('overall_status', 'unknown')
+            
+            print(f"   📈 Overall status: {overall_status}")
+            print(f"   ⏰ Oldest data: {oldest_minutes} minutes")
+            
+            # 관측소별 상태
+            stations = fresh_data.get('stations', {})
+            fresh_count = sum(1 for s in stations.values() if s.get('status') == 'fresh')
+            total_count = len(stations)
+            
+            print(f"   🏪 Fresh stations: {fresh_count}/{total_count}")
+            
+            # 문제가 있는 관측소 표시
+            stale_stations = [sid for sid, data in stations.items() 
+                            if data.get('status') != 'fresh']
+            
+            if stale_stations:
+                print(f"   ⚠️ Stale stations: {', '.join(stale_stations)}")
+            
+            is_healthy = overall_status == 'healthy' and oldest_minutes < 15
+            return is_healthy, fresh_data
+        else:
+            print(f"   ❌ Data freshness check failed: {response.status_code}")
+            return False, None
+            
+    except Exception as e:
+        print(f"   ❌ Data freshness error: {e}")
+        return False, None
+
+def check_prediction_performance():
+    """예측 성능 확인"""
+    
+    print("🎯 Checking prediction performance...")
+    
+    try:
+        response = requests.get(
+            f"{HF_SPACE_URL}/api/performance/realtime",
+            headers={'Authorization': f'Bearer {API_KEY}'},
+            timeout=10
+        )
+        
+        if response.status_code == 200:
+            perf_data = response.json()
+            
+            rmse = perf_data.get('rmse', 'N/A')
+            mae = perf_data.get('mae', 'N/A')
+            accuracy = perf_data.get('accuracy', 'N/A')
+            
+            print(f"   📊 RMSE: {rmse} cm")
+            print(f"   📊 MAE: {mae} cm")
+            print(f"   🎯 Accuracy: {accuracy}%")
+            
+            # 성능 평가
+            rmse_ok = isinstance(rmse, (int, float)) and rmse < 50  # 50cm 미만
+            accuracy_ok = isinstance(accuracy, (int, float)) and accuracy > 80  # 80% 이상
+            
+            if rmse_ok and accuracy_ok:
+                print("   ✅ Performance: GOOD")
+                performance_status = 'good'
+            elif rmse_ok or accuracy_ok:
+                print("   ⚠️ Performance: MODERATE")
+                performance_status = 'moderate'
+            else:
+                print("   ❌ Performance: POOR")
+                performance_status = 'poor'
+            
+            return performance_status in ['good', 'moderate'], perf_data
+        else:
+            print(f"   ❌ Performance check failed: {response.status_code}")
+            return False, None
+            
+    except Exception as e:
+        print(f"   ❌ Performance check error: {e}")
+        return False, None
+
+def test_prediction_endpoints():
+    """예측 엔드포인트 테스트"""
+    
+    print("🔮 Testing prediction endpoints...")
+    
+    test_endpoints = [
+        ('/api/tide_level?station_id=DT_0001', 'Tide level prediction'),
+        ('/api/extremes?station_id=DT_0001', 'Extremes analysis'),
+        ('/api/alert?station_id=DT_0001', 'Alert system')
+    ]
+    
+    working_endpoints = 0
+    
+    for endpoint, description in test_endpoints:
+        try:
+            response = requests.get(f"{HF_SPACE_URL}{endpoint}", timeout=10)
+            
+            if response.status_code == 200:
+                print(f"   ✅ {description}: OK")
+                working_endpoints += 1
+            else:
+                print(f"   ❌ {description}: ERROR ({response.status_code})")
+                
+        except Exception as e:
+            print(f"   ❌ {description}: EXCEPTION ({e})")
+    
+    success_rate = working_endpoints / len(test_endpoints)
+    print(f"   📊 Endpoint success rate: {success_rate:.1%} ({working_endpoints}/{len(test_endpoints)})")
+    
+    return success_rate > 0.8  # 80% 이상 성공
+
+def measure_response_times():
+    """응답 시간 측정"""
+    
+    print("⏱️ Measuring response times...")
+    
+    test_urls = [
+        ('/api/health', 'Health check'),
+        ('/api/tide_level?station_id=DT_0001', 'Tide prediction'),
+        ('/api/internal/demo_status', 'Demo status')
+    ]
+    
+    response_times = {}
+    
+    for endpoint, description in test_urls:
+        try:
+            start_time = time.time()
+            
+            headers = {}
+            if 'internal' in endpoint:
+                headers['Authorization'] = f'Bearer {API_KEY}'
+            
+            response = requests.get(f"{HF_SPACE_URL}{endpoint}", headers=headers, timeout=10)
+            
+            end_time = time.time()
+            response_time = (end_time - start_time) * 1000  # ms
+            
+            response_times[endpoint] = response_time
+            
+            if response_time < 1000:
+                status = "✅ FAST"
+            elif response_time < 3000:
+                status = "⚠️ MODERATE"
+            else:
+                status = "❌ SLOW"
+            
+            print(f"   {description}: {response_time:.0f}ms {status}")
+            
+        except Exception as e:
+            print(f"   ❌ {description}: TIMEOUT or ERROR")
+            response_times[endpoint] = None
+    
+    avg_time = sum(t for t in response_times.values() if t is not None) / len([t for t in response_times.values() if t is not None])
+    print(f"   📊 Average response time: {avg_time:.0f}ms")
+    
+    return avg_time < 2000  # 2초 미만
+
+def comprehensive_health_check():
+    """종합 상태 점검"""
+    
+    print("🏥 Starting comprehensive health check...")
+    print(f"🕐 Check started at: {datetime.now().isoformat()}")
+    print("=" * 60)
+    
+    checks = [
+        ("Basic Connectivity", test_basic_connectivity),
+        ("API Authentication", test_api_authentication),
+        ("Demo Status", check_demo_status),
+        ("Data Freshness", check_data_freshness),
+        ("Prediction Performance", check_prediction_performance),
+        ("Prediction Endpoints", test_prediction_endpoints),
+        ("Response Times", measure_response_times)
+    ]
+    
+    results = {}
+    passed_checks = 0
+    
+    for check_name, check_function in checks:
+        print(f"\n🔍 {check_name}:")
+        
+        try:
+            if check_function.__name__ in ['test_basic_connectivity', 'check_demo_status', 'check_data_freshness', 'check_prediction_performance']:
+                # 이 함수들은 (success, data) 튜플 반환
+                success, data = check_function()
+                results[check_name] = {
+                    'success': success,
+                    'data': data,
+                    'timestamp': datetime.now().isoformat()
+                }
+            else:
+                # 나머지 함수들은 boolean 반환
+                success = check_function()
+                results[check_name] = {
+                    'success': success,
+                    'timestamp': datetime.now().isoformat()
+                }
+            
+            if success:
+                passed_checks += 1
+                
+        except Exception as e:
+            print(f"   ❌ Check failed with exception: {e}")
+            results[check_name] = {
+                'success': False,
+                'error': str(e),
+                'timestamp': datetime.now().isoformat()
+            }
+    
+    # 최종 결과 요약
+    total_checks = len(checks)
+    success_rate = passed_checks / total_checks
+    
+    print("\n" + "=" * 60)
+    print("📊 HEALTH CHECK SUMMARY")
+    print("=" * 60)
+    print(f"✅ Passed checks: {passed_checks}/{total_checks}")
+    print(f"📈 Success rate: {success_rate:.1%}")
+    
+    if success_rate >= 0.9:
+        overall_status = "🟢 EXCELLENT"
+        status_code = 0
+    elif success_rate >= 0.7:
+        overall_status = "🟡 GOOD"
+        status_code = 0
+    elif success_rate >= 0.5:
+        overall_status = "🟠 WARNING"
+        status_code = 1
+    else:
+        overall_status = "🔴 CRITICAL"
+        status_code = 2
+    
+    print(f"🎯 Overall status: {overall_status}")
+    
+    # 권장사항
+    if success_rate < 1.0:
+        print("\n💡 Recommendations:")
+        
+        failed_checks = [name for name, result in results.items() if not result.get('success', False)]
+        
+        for failed_check in failed_checks:
+            if 'Connectivity' in failed_check:
+                print("   🌐 Check HF Space deployment status")
+            elif 'Authentication' in failed_check:
+                print("   🔐 Verify INTERNAL_API_KEY environment variable")
+            elif 'Demo Status' in failed_check:
+                print("   🎬 Consider starting demo session")
+            elif 'Data Freshness' in failed_check:
+                print("   📊 Check data collection pipeline")
+            elif 'Performance' in failed_check:
+                print("   🎯 Review prediction model performance")
+            elif 'Endpoints' in failed_check:
+                print("   🔮 Check prediction service status")
+            elif 'Response Times' in failed_check:
+                print("   ⏱️ Consider system resource optimization")
+    
+    # 결과 저장
+    health_report = {
+        'check_timestamp': datetime.now().isoformat(),
+        'overall_status': overall_status,
+        'success_rate': success_rate,
+        'passed_checks': passed_checks,
+        'total_checks': total_checks,
+        'check_results': results
+    }
+    
+    with open(f'health_report_{datetime.now().strftime("%Y%m%d_%H%M%S")}.json', 'w') as f:
+        json.dump(health_report, f, indent=2)
+    
+    print(f"\n📄 Detailed report saved to health_report_*.json")
+    
+    return status_code
+
+if __name__ == '__main__':
+    if not HF_SPACE_URL:
+        print("❌ HF_SPACE_URL environment variable is required")
+        sys.exit(1)
+    
+    # 인자 처리
+    quick_mode = len(sys.argv) > 1 and sys.argv[1] == 'quick'
+    
+    if quick_mode:
+        print("⚡ Quick health check mode")
+        
+        # 기본 연결성만 확인
+        connectivity_ok, _ = test_basic_connectivity()
+        auth_ok = test_api_authentication() if API_KEY else False
+        
+        if connectivity_ok and (auth_ok or not API_KEY):
+            print("✅ Basic health: OK")
+            sys.exit(0)
+        else:
+            print("❌ Basic health: FAILED")
+            sys.exit(1)
+    else:
+        # 종합 상태 점검
+        exit_code = comprehensive_health_check()
+        sys.exit(exit_code)

.github/scripts/send_data_batch.py

@@ -0,0 +1,252 @@
+#!/usr/bin/env python3
+"""
+Data Batch Sender - 배치 데이터 전송
+"""
+
+import os
+import sys
+import pandas as pd
+import numpy as np
+import requests
+import json
+from datetime import datetime, timedelta
+from pathlib import Path
+
+def load_station_data(station_id, start_time, num_points=12):
+    """관측소 데이터 로드 (실제 txt 파일 또는 시뮬레이션)"""
+    
+    # 실제 데이터 파일 경로 확인
+    possible_paths = [
+        Path(f"data/2025_07_{station_id}_TEST.txt"),
+        Path(f"data/{station_id}_2025_07.txt"),
+        Path(f"data/{station_id}.txt"),
+        Path(f"2025_07_{station_id}_TEST.txt")
+    ]
+    
+    data_file = None
+    for path in possible_paths:
+        if path.exists():
+            data_file = path
+            break
+    
+    if data_file:
+        try:
+            print(f"📁 Loading real data from: {data_file}")
+            
+            # 인코딩 자동 감지
+            encodings = ['cp949', 'utf-8', 'euc-kr']
+            df = None
+            
+            for encoding in encodings:
+                try:
+                    df = pd.read_csv(
+                        data_file,
+                        encoding=encoding,
+                        sep='\t',
+                        skiprows=3
+                    )
+                    print(f"✅ Successfully loaded with {encoding} encoding")
+                    break
+                except UnicodeDecodeError:
+                    continue
+            
+            if df is None:
+                raise Exception("Could not decode file with any encoding")
+            
+            # 컬럼명 정규화
+            expected_columns = ['관측시간', '기압(hPa)', '풍향(deg)', '풍속(m/s)', '기온(℃)', '조위(cm)']
+            
+            if len(df.columns) >= 6:
+                df = df.iloc[:, :6]  # 처음 6개 컬럼만 사용
+                df.columns = ['date', 'air_pres', 'wind_dir', 'wind_speed', 'air_temp', 'tide_level']
+            else:
+                raise Exception(f"Expected 6 columns, got {len(df.columns)}")
+            
+            # 날짜 변환
+            df['date'] = pd.to_datetime(df['date'], errors='coerce')
+            
+            # 숫자형 변환
+            for col in ['air_pres', 'wind_dir', 'wind_speed', 'air_temp', 'tide_level']:
+                df[col] = pd.to_numeric(df[col], errors='coerce')
+            
+            # 결측치 제거
+            df = df.dropna()
+            
+            # 시작 시간부터 필요한 포인트 추출
+            start_dt = datetime.fromisoformat(start_time.replace('Z', '+00:00') if start_time.endswith('Z') else start_time)
+            
+            # 가장 가까운 시간 찾기
+            if not df.empty:
+                time_diff = (df['date'] - start_dt).abs()
+                start_idx = time_diff.idxmin()
+                
+                # 해당 인덱스부터 num_points만큼 추출
+                selected_data = df.loc[start_idx:start_idx+num_points-1]
+                
+                if len(selected_data) < num_points:
+                    # 데이터가 부족하면 마지막부터 추출
+                    selected_data = df.tail(num_points)
+                
+                print(f"📊 Extracted {len(selected_data)} real data points")
+                return selected_data.to_dict('records')
+            
+        except Exception as e:
+            print(f"⚠️ Error reading {station_id} data from {data_file}: {e}")
+            print("🔄 Falling back to simulation data")
+    
+    # 시뮬레이션 데이터 생성
+    print(f"🎲 Generating simulation data for {station_id}")
+    
+    start_dt = datetime.fromisoformat(start_time.replace('Z', '+00:00') if start_time.endswith('Z') else start_time)
+    data_points = []
+    
+    # 관측소별 시드 설정 (일관된 데이터)
+    np.random.seed(hash(station_id) % 2**32)
+    
+    for i in range(num_points):
+        current_time = start_dt + timedelta(minutes=i*5)
+        
+        # 시간 기반 패턴
+        hour_angle = 2 * np.pi * current_time.hour / 24
+        tide_angle = 2 * np.pi * current_time.hour / 12.42  # M2 조석
+        
+        # 기본 시뮬레이션 데이터
+        data_point = {
+            'date': current_time.strftime('%Y-%m-%d %H:%M:%S'),
+            'station_id': station_id,
+            'air_pres': round(1013.0 + 10 * np.sin(hour_angle) + np.random.normal(0, 3), 1),
+            'wind_dir': round(180 + 90 * np.sin(hour_angle) + np.random.uniform(-30, 30), 1),
+            'wind_speed': round(max(0, 3 + 2 * np.sin(hour_angle) + np.random.normal(0, 1)), 1),
+            'air_temp': round(25 + 5 * np.sin(hour_angle) + np.random.normal(0, 1), 1),
+            'tide_level': round(300 + 200 * np.sin(tide_angle) + 50 * np.sin(2*tide_angle) + np.random.normal(0, 15), 1)
+        }
+        
+        data_points.append(data_point)
+    
+    return data_points
+
+def get_current_simulation_time():
+    """현재 시뮬레이션 시간 가져오기"""
+    
+    HF_SPACE_URL = os.environ.get('HF_SPACE_URL')
+    API_KEY = os.environ.get('INTERNAL_API_KEY')
+    
+    try:
+        response = requests.get(
+            f"{HF_SPACE_URL}/api/internal/simulation_status",
+            headers={'Authorization': f'Bearer {API_KEY}'},
+            timeout=10
+        )
+        
+        if response.status_code == 200:
+            sim_status = response.json()
+            return sim_status.get('current_simulation_time', '2025-07-01T00:00:00')
+        else:
+            print(f"⚠️ Could not get simulation status: {response.status_code}")
+            return '2025-07-01T00:00:00'
+            
+    except Exception as e:
+        print(f"⚠️ Error getting simulation status: {e}")
+        return '2025-07-01T00:00:00'
+
+def send_batch_data():
+    """배치 데이터 전송"""
+    
+    HF_SPACE_URL = os.environ.get('HF_SPACE_URL')
+    API_KEY = os.environ.get('INTERNAL_API_KEY')
+    BATCH_SIZE = int(os.environ.get('INPUT_BATCH_SIZE', '12'))
+    
+    if not HF_SPACE_URL or not API_KEY:
+        print("❌ Missing environment variables")
+        sys.exit(1)
+    
+    # 현재 시뮬레이션 시간 가져오기
+    current_sim_time = get_current_simulation_time()
+    
+    print(f"📦 Sending batch data from: {current_sim_time}")
+    print(f"📊 Batch size: {BATCH_SIZE} points per station (= {BATCH_SIZE * 5} minutes)")
+    
+    # 시연용 관측소들
+    demo_stations = ['DT_0001', 'DT_0002', 'DT_0003', 'DT_0008', 'DT_0017']
+    
+    # 모든 관측소 데이터 수집
+    all_data = []
+    successful_stations = []
+    
+    for station_id in demo_stations:
+        try:
+            station_data = load_station_data(station_id, current_sim_time, BATCH_SIZE)
+            if station_data:
+                # station_id를 각 데이터 포인트에 추가
+                for point in station_data:
+                    point['station_id'] = station_id
+                
+                all_data.extend(station_data)
+                successful_stations.append(station_id)
+                print(f"✅ {station_id}: {len(station_data)} points loaded")
+            else:
+                print(f"❌ {station_id}: No data loaded")
+                
+        except Exception as e:
+            print(f"❌ {station_id}: Error loading data - {e}")
+    
+    if not all_data:
+        print("❌ No data to send")
+        sys.exit(1)
+    
+    # HF Space로 전송할 페이로드 구성
+    payload = {
+        'task': 'batch_data_collection',
+        'timestamp': datetime.now().isoformat(),
+        'simulation_time': current_sim_time,
+        'batch_size': BATCH_SIZE,
+        'stations_data': all_data,
+        'metadata': {
+            'total_points': len(all_data),
+            'stations_count': len(successful_stations),
+            'successful_stations': successful_stations,
+            'time_range_minutes': BATCH_SIZE * 5,
+            'data_source': 'mixed'  # 실제 + 시뮬레이션
+        }
+    }
+    
+    print(f"🚀 Sending {len(all_data)} data points to HF Space...")
+    
+    try:
+        response = requests.post(
+            f"{HF_SPACE_URL}/api/internal/collect_data",
+            headers={
+                'Authorization': f'Bearer {API_KEY}',
+                'Content-Type': 'application/json'
+            },
+            json=payload,
+            timeout=60
+        )
+        
+        if response.status_code == 200:
+            result = response.json()
+            print("✅ Batch data sent successfully!")
+            print(f"📊 Records processed: {result.get('records_saved', 0)}")
+            print(f"🏪 Stations processed: {result.get('stations_processed', 0)}")
+            print(f"⏱️ Processing time: {result.get('processing_time_ms', 0)}ms")
+            
+            # 성공 결과 저장
+            with open('batch_send_result.json', 'w') as f:
+                json.dump(result, f, indent=2)
+                
+        else:
+            print(f"❌ Failed to send batch data: {response.status_code}")
+            print(f"Response: {response.text}")
+            sys.exit(1)
+            
+    except Exception as e:
+        print(f"❌ Error sending batch data: {e}")
+        sys.exit(1)
+
+if __name__ == '__main__':
+    print("📦 Starting batch data transmission...")
+    print(f"🕐 Current time: {datetime.now().isoformat()}")
+    
+    send_batch_data()
+    
+    print("🎉 Batch data transmission completed!")

.github/scripts/system_recovery.py

@@ -0,0 +1,359 @@
+#!/usr/bin/env python3
+"""
+System Recovery - 시스템 복구 및 정상화
+"""
+
+import os
+import sys
+import requests
+import json
+import time
+from datetime import datetime
+
+HF_SPACE_URL = os.environ.get('HF_SPACE_URL')
+API_KEY = os.environ.get('INTERNAL_API_KEY')
+
+def check_system_status():
+    """현재 시스템 상태 확인"""
+    
+    print("🔍 Checking current system status...")
+    
+    status_checks = {
+        'basic_health': '/api/health',
+        'demo_status': '/api/internal/demo_status',
+        'data_freshness': '/api/internal/data_freshness',
+        'performance': '/api/performance/realtime'
+    }
+    
+    results = {}
+    
+    for check_name, endpoint in status_checks.items():
+        try:
+            headers = {'Authorization': f'Bearer {API_KEY}'} if 'internal' in endpoint or 'performance' in endpoint else {}
+            
+            response = requests.get(
+                f"{HF_SPACE_URL}{endpoint}",
+                headers=headers,
+                timeout=10
+            )
+            
+            if response.status_code == 200:
+                results[check_name] = {
+                    'status': 'ok',
+                    'data': response.json()
+                }
+                print(f"   ✅ {check_name}: OK")
+            else:
+                results[check_name] = {
+                    'status': 'error',
+                    'code': response.status_code,
+                    'data': response.text
+                }
+                print(f"   ❌ {check_name}: ERROR ({response.status_code})")
+                
+        except Exception as e:
+            results[check_name] = {
+                'status': 'exception',
+                'error': str(e)
+            }
+            print(f"   ⚠️ {check_name}: EXCEPTION ({e})")
+    
+    return results
+
+def clear_active_issues():
+    """활성 문제 상황 모두 해제"""
+    
+    print("🔧 Clearing all active issues...")
+    
+    payload = {
+        'action': 'clear_all_issues',
+        'timestamp': datetime.now().isoformat(),
+        'forced': True
+    }
+    
+    try:
+        response = requests.post(
+            f"{HF_SPACE_URL}/api/internal/system_recovery",
+            headers={
+                'Authorization': f'Bearer {API_KEY}',
+                'Content-Type': 'application/json'
+            },
+            json=payload,
+            timeout=30
+        )
+        
+        if response.status_code == 200:
+            result = response.json()
+            cleared_issues = result.get('cleared_issues', [])
+            
+            print(f"✅ Cleared {len(cleared_issues)} active issues")
+            for issue in cleared_issues:
+                print(f"   🔄 {issue.get('type', 'unknown')}: {issue.get('description', 'N/A')}")
+            
+            return True
+        else:
+            print(f"❌ Failed to clear issues: {response.status_code}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ Error clearing issues: {e}")
+        return False
+
+def reset_simulation_state():
+    """시뮬레이션 상태 리셋"""
+    
+    print("🔄 Resetting simulation state...")
+    
+    payload = {
+        'action': 'reset_simulation',
+        'timestamp': datetime.now().isoformat(),
+        'preserve_data': True,  # 기존 데이터는 보존
+        'reset_counters': True,
+        'clear_cache': True
+    }
+    
+    try:
+        response = requests.post(
+            f"{HF_SPACE_URL}/api/internal/system_recovery",
+            headers={
+                'Authorization': f'Bearer {API_KEY}',
+                'Content-Type': 'application/json'
+            },
+            json=payload,
+            timeout=30
+        )
+        
+        if response.status_code == 200:
+            result = response.json()
+            print("✅ Simulation state reset successfully")
+            print(f"   📊 Data points preserved: {result.get('preserved_records', 0)}")
+            print(f"   🧹 Cache cleared: {result.get('cache_cleared', False)}")
+            print(f"   🔢 Counters reset: {result.get('counters_reset', False)}")
+            return True
+        else:
+            print(f"❌ Failed to reset simulation: {response.status_code}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ Error resetting simulation: {e}")
+        return False
+
+def restart_data_collection():
+    """데이터 수집 재시작"""
+    
+    print("📡 Restarting data collection services...")
+    
+    # 먼저 수집 중지
+    stop_payload = {
+        'action': 'stop_collection',
+        'timestamp': datetime.now().isoformat()
+    }
+    
+    try:
+        response = requests.post(
+            f"{HF_SPACE_URL}/api/internal/collection_control",
+            headers={
+                'Authorization': f'Bearer {API_KEY}',
+                'Content-Type': 'application/json'
+            },
+            json=stop_payload,
+            timeout=15
+        )
+        
+        if response.status_code == 200:
+            print("   🛑 Data collection stopped")
+        else:
+            print(f"   ⚠️ Stop collection warning: {response.status_code}")
+    
+    except Exception as e:
+        print(f"   ⚠️ Stop collection error: {e}")
+    
+    # 잠시 대기
+    time.sleep(2)
+    
+    # 수집 재시작
+    start_payload = {
+        'action': 'start_collection',
+        'timestamp': datetime.now().isoformat(),
+        'stations': ['DT_0001', 'DT_0002', 'DT_0003', 'DT_0008', 'DT_0017'],
+        'fresh_start': True
+    }
+    
+    try:
+        response = requests.post(
+            f"{HF_SPACE_URL}/api/internal/collection_control",
+            headers={
+                'Authorization': f'Bearer {API_KEY}',
+                'Content-Type': 'application/json'
+            },
+            json=start_payload,
+            timeout=15
+        )
+        
+        if response.status_code == 200:
+            result = response.json()
+            print("   ✅ Data collection restarted")
+            print(f"   🏪 Active stations: {len(result.get('active_stations', []))}")
+            return True
+        else:
+            print(f"   ❌ Failed to restart collection: {response.status_code}")
+            return False
+            
+    except Exception as e:
+        print(f"   ❌ Error restarting collection: {e}")
+        return False
+
+def verify_recovery():
+    """복구 상태 검증"""
+    
+    print("🔍 Verifying system recovery...")
+    
+    # 5초 대기 후 상태 재확인
+    time.sleep(5)
+    
+    status_results = check_system_status()
+    
+    # 기본 상태 확인
+    health_ok = status_results.get('basic_health', {}).get('status') == 'ok'
+    demo_ok = status_results.get('demo_status', {}).get('status') == 'ok'
+    
+    if health_ok and demo_ok:
+        print("✅ System recovery verification PASSED")
+        
+        # 상세 상태 출력
+        if 'performance' in status_results and status_results['performance']['status'] == 'ok':
+            perf_data = status_results['performance']['data']
+            rmse = perf_data.get('rmse', 'N/A')
+            accuracy = perf_data.get('accuracy', 'N/A')
+            print(f"   📈 Current RMSE: {rmse}")
+            print(f"   🎯 Current accuracy: {accuracy}%")
+        
+        if 'data_freshness' in status_results and status_results['data_freshness']['status'] == 'ok':
+            fresh_data = status_results['data_freshness']['data']
+            oldest_minutes = fresh_data.get('oldest_data_minutes', 'N/A')
+            print(f"   ⏰ Data freshness: {oldest_minutes} minutes")
+        
+        return True
+    else:
+        print("❌ System recovery verification FAILED")
+        
+        if not health_ok:
+            print("   🚨 Basic health check still failing")
+        if not demo_ok:
+            print("   🚨 Demo status still problematic")
+        
+        return False
+
+def full_system_recovery():
+    """전체 시스템 복구 프로세스"""
+    
+    print("🚀 Starting full system recovery process...")
+    print(f"🕐 Recovery started at: {datetime.now().isoformat()}")
+    
+    recovery_steps = [
+        ("Checking initial status", check_system_status),
+        ("Clearing active issues", clear_active_issues),
+        ("Resetting simulation state", reset_simulation_state),
+        ("Restarting data collection", restart_data_collection),
+        ("Verifying recovery", verify_recovery)
+    ]
+    
+    results = {}
+    
+    for step_name, step_function in recovery_steps:
+        print(f"\n🔧 Step: {step_name}")
+        
+        try:
+            result = step_function()
+            results[step_name] = {
+                'success': result if isinstance(result, bool) else True,
+                'timestamp': datetime.now().isoformat()
+            }
+            
+            if isinstance(result, bool) and not result:
+                print(f"⚠️ Step '{step_name}' reported failure but continuing...")
+            
+        except Exception as e:
+            print(f"❌ Step '{step_name}' failed with exception: {e}")
+            results[step_name] = {
+                'success': False,
+                'error': str(e),
+                'timestamp': datetime.now().isoformat()
+            }
+    
+    # 최종 결과 요약
+    successful_steps = sum(1 for r in results.values() if r.get('success', False))
+    total_steps = len(recovery_steps)
+    
+    print(f"\n📊 Recovery Summary:")
+    print(f"   ✅ Successful steps: {successful_steps}/{total_steps}")
+    print(f"   ⏱️ Total recovery time: ~{(datetime.now().hour * 60 + datetime.now().minute) % 60} seconds")
+    
+    if successful_steps >= total_steps - 1:  # 최소 4/5 성공하면 OK
+        print("🎉 System recovery COMPLETED successfully!")
+        recovery_success = True
+    else:
+        print("⚠️ System recovery PARTIALLY completed")
+        recovery_success = False
+    
+    # 복구 결과 저장
+    recovery_report = {
+        'recovery_timestamp': datetime.now().isoformat(),
+        'success': recovery_success,
+        'steps': results,
+        'summary': {
+            'successful_steps': successful_steps,
+            'total_steps': total_steps,
+            'success_rate': successful_steps / total_steps
+        }
+    }
+    
+    with open(f'recovery_report_{datetime.now().strftime("%Y%m%d_%H%M%S")}.json', 'w') as f:
+        json.dump(recovery_report, f, indent=2)
+    
+    return recovery_success
+
+if __name__ == '__main__':
+    if not HF_SPACE_URL or not API_KEY:
+        print("❌ Missing environment variables:")
+        print("   HF_SPACE_URL:", "✓" if HF_SPACE_URL else "✗")
+        print("   INTERNAL_API_KEY:", "✓" if API_KEY else "✗")
+        sys.exit(1)
+    
+    # 인자 처리
+    if len(sys.argv) > 1:
+        action = sys.argv[1]
+        
+        if action == 'status':
+            print("🔍 System status check only...")
+            status = check_system_status()
+            sys.exit(0)
+        elif action == 'clear':
+            print("🔧 Clearing issues only...")
+            clear_active_issues()
+            sys.exit(0)
+        elif action == 'reset':
+            print("🔄 Reset simulation only...")
+            reset_simulation_state()
+            sys.exit(0)
+        elif action == 'restart':
+            print("📡 Restart collection only...")
+            restart_data_collection()
+            sys.exit(0)
+        elif action != 'full':
+            print("Usage: python system_recovery.py [status|clear|reset|restart|full]")
+            print("   status  - Check system status only")
+            print("   clear   - Clear active issues only")  
+            print("   reset   - Reset simulation state only")
+            print("   restart - Restart data collection only")
+            print("   full    - Full recovery process (default)")
+            sys.exit(1)
+    
+    # 전체 복구 실행
+    success = full_system_recovery()
+    
+    if not success:
+        print("\n⚠️ Recovery was not fully successful. Manual intervention may be required.")
+        sys.exit(1)
+    else:
+        print("\n🎉 System is ready for demonstration!")

.github/scripts/trigger_issue.py

@@ -0,0 +1,467 @@
+#!/usr/bin/env python3
+"""
+Issue Trigger - 문제 상황 발생 시뮬레이션
+"""
+
+import os
+import sys
+import requests
+import json
+import random
+from datetime import datetime, timedelta
+
+HF_SPACE_URL = os.environ.get('HF_SPACE_URL')
+API_KEY = os.environ.get('INTERNAL_API_KEY')
+
+def get_issue_config(issue_type, station_id=None):
+    """문제 유형별 설정 생성"""
+    
+    configs = {
+        'network_failure': {
+            'description': 'Network connectivity issues',
+            'duration_seconds': random.randint(30, 120),
+            'failure_rate': random.uniform(0.7, 0.9),
+            'affected_endpoints': ['/api/internal/collect_data', '/api/internal/update_predictions'],
+            'recovery_time': random.randint(15, 45),
+            'symptoms': ['timeout errors', 'connection refused', 'partial data loss']
+        },
+        
+        'extreme_weather': {
+            'description': 'Extreme weather conditions (typhoon simulation)',
+            'magnitude': random.choice(['moderate', 'high', 'severe']),
+            'duration_minutes': random.randint(60, 180),
+            'affected_parameters': {
+                'tide_level': {'offset': random.randint(150, 400), 'noise_factor': 3.0},
+                'wind_speed': {'multiplier': random.uniform(2.5, 5.0)},
+                'air_pres': {'offset': random.randint(-30, -15)},
+                'wind_dir': {'chaos_factor': 0.8}  # 풍향 불안정
+            },
+            'warning_threshold': 750.0,  # cm
+            'danger_threshold': 900.0
+        },
+        
+        'sensor_malfunction': {
+            'description': f'Sensor malfunction at station {station_id or "random"}',
+            'target_station': station_id or random.choice(['DT_0001', 'DT_0002', 'DT_0003']),
+            'malfunction_type': random.choice(['data_loss', 'frozen_values', 'random_noise', 'calibration_drift']),
+            'affected_sensors': random.sample(['tide_level', 'air_temp', 'air_pres', 'wind_speed'], 
+                                            random.randint(1, 3)),
+            'duration_minutes': random.randint(30, 90),
+            'recovery_probability': 0.8
+        },
+        
+        'data_corruption': {
+            'description': 'Data transmission corruption',
+            'corruption_rate': random.uniform(0.1, 0.4),
+            'corruption_types': ['missing_fields', 'invalid_values', 'timestamp_errors', 'encoding_issues'],
+            'affected_stations': random.sample(['DT_0001', 'DT_0002', 'DT_0003', 'DT_0008', 'DT_0017'], 
+                                             random.randint(2, 4)),
+            'duration_minutes': random.randint(15, 60)
+        }
+    }
+    
+    return configs.get(issue_type, {})
+
+def trigger_issue(issue_type, station_id=None):
+    """문제 상황 발생"""
+    
+    if not HF_SPACE_URL or not API_KEY:
+        print("❌ Missing environment variables")
+        sys.exit(1)
+    
+    print(f"⚠️ Triggering issue: {issue_type}")
+    if station_id:
+        print(f"🎯 Target station: {station_id}")
+    
+    # 문제 설정 생성
+    issue_config = get_issue_config(issue_type, station_id)
+    
+    if not issue_config:
+        print(f"❌ Unknown issue type: {issue_type}")
+        print("Available types: network_failure, extreme_weather, sensor_malfunction, data_corruption")
+        sys.exit(1)
+    
+    # API 페이로드 구성
+    payload = {
+        'action': 'trigger_issue',
+        'issue_type': issue_type,
+        'station_id': station_id,
+        'timestamp': datetime.now().isoformat(),
+        'severity': 'demo',
+        'config': issue_config,
+        'auto_recovery': True,  # 자동 복구 활성화
+        'notification': True    # 알림 활성화
+    }
+    
+    # 문제 유형별 특별 처리
+    if issue_type == 'network_failure':
+        print(f"🌐 Simulating network failure for {issue_config['duration_seconds']} seconds")
+        print(f"📊 Failure rate: {issue_config['failure_rate']:.1%}")
+        
+    elif issue_type == 'extreme_weather':
+        magnitude = issue_config['magnitude']
+        duration = issue_config['duration_minutes']
+        print(f"🌪️ Simulating {magnitude} extreme weather for {duration} minutes")
+        print(f"🌊 Expected tide surge: +{issue_config['affected_parameters']['tide_level']['offset']} cm")
+        
+    elif issue_type == 'sensor_malfunction':
+        target = issue_config['target_station']
+        malfunction = issue_config['malfunction_type']
+        sensors = issue_config['affected_sensors']
+        print(f"🔧 Simulating {malfunction} at {target}")
+        print(f"📡 Affected sensors: {', '.join(sensors)}")
+        
+    elif issue_type == 'data_corruption':
+        rate = issue_config['corruption_rate']
+        stations = issue_config['affected_stations']
+        print(f"🔀 Simulating data corruption ({rate:.1%} rate)")
+        print(f"🏪 Affected stations: {', '.join(stations)}")
+    
+    try:
+        print("🚀 Sending issue trigger to HF Space...")
+        
+        response = requests.post(
+            f"{HF_SPACE_URL}/api/internal/trigger_demo",
+            headers={
+                'Authorization': f'Bearer {API_KEY}',
+                'Content-Type': 'application/json'
+            },
+            json=payload,
+            timeout=30
+        )
+        
+        if response.status_code == 200:
+            result = response.json()
+            print("✅ Issue triggered successfully!")
+            
+            print("\n📊 Issue Details:")
+            print(f"   🎯 Target: {result.get('target', 'system-wide')}")
+            print(f"   ⏱️ Duration: {result.get('expected_duration', 'variable')}")
+            print(f"   📈 Expected impact: {result.get('expected_impact', 'monitoring required')}")
+            print(f"   🔄 Auto recovery: {result.get('auto_recovery', 'enabled')}")
+            
+            if 'issue_id' in result:
+                print(f"   🆔 Issue ID: {result['issue_id']}")
+            
+            # 모니터링 권장사항
+            print("\n🔍 Monitoring recommendations:")
+            if issue_type == 'network_failure':
+                print("   - Watch for API timeout errors")
+                print("   - Monitor data collection success rate")
+                print("   - Check system health dashboard")
+                
+            elif issue_type == 'extreme_weather':
+                print("   - Monitor tide level predictions")
+                print("   - Watch for alert threshold breaches")
+                print("   - Check RMSE increase")
+                
+            elif issue_type == 'sensor_malfunction':
+                print(f"   - Monitor {issue_config['target_station']} data quality")
+                print("   - Watch for missing data warnings")
+                print("   - Check interpolation accuracy")
+                
+            elif issue_type == 'data_corruption':
+                print("   - Monitor data validation errors")
+                print("   - Check processing success rate")
+                print("   - Watch for data quality alerts")
+            
+            # 결과 저장
+            with open(f'issue_trigger_{issue_type}_{datetime.now().strftime("%H%M%S")}.json', 'w') as f:
+                json.dump(result, f, indent=2)
+                
+        else:
+            print(f"❌ Failed to trigger issue: {response.status_code}")
+            print(f"Response: {response.text}")
+            
+            # 에러 상세 정보
+            try:
+                error_detail = response.json()
+                if 'detail' in error_detail:
+                    print(f"Error detail: {error_detail['detail']}")
+            except:
+                pass
+                
+            sys.exit(1)
+            
+    except requests.exceptions.Timeout:
+        print("⏱️ Request timed out (this might be part of network failure simulation)")
+        if issue_type == 'network_failure':
+            print("✅ Network failure simulation appears to be working!")
+        else:
+            sys.exit(1)
+            
+    except Exception as e:
+        print(f"❌ Error triggering issue: {e}")
+        sys.exit(1)
+
+def list_available_issues():
+    """사용 가능한 문제 유형 목록"""
+    
+    issues = {
+        'network_failure': 'Network connectivity problems, API timeouts',
+        'extreme_weather': 'Typhoon/storm simulation with extreme tide levels',
+        'sensor_malfunction': 'Individual station sensor failures',
+        'data_corruption': 'Data transmission and validation errors'
+    }
+    
+    print("🔧 Available issue types:")
+    for issue_type, description in issues.items():
+        print(f"   {issue_type}: {description}")
+
+if __name__ == '__main__':
+    if len(sys.argv) < 2:
+        print("Usage: python trigger_issue.py <issue_type> [station_id]")
+        print()
+        list_available_issues()
+        print()
+        print("Examples:")
+        print("  python trigger_issue.py network_failure")
+        print("  python trigger_issue.py extreme_weather")
+        print("  python trigger_issue.py sensor_malfunction DT_0001")
+        print("  python trigger_issue.py data_corruption")
+        sys.exit(1)
+    
+    issue_type = sys.argv[1]
+    station_id = sys.argv[2] if len(sys.argv) > 2 else None
+    
+    if issue_type == 'list':
+        list_available_issues()
+        sys.exit(0)
+    
+    print(f"🎭 Starting issue simulation: {issue_type}")
+    print(f"🕐 Current time: {datetime.now().isoformat()}")
+    
+    trigger_issue(issue_type, station_id)#!/usr/bin/env python3
+"""
+Issue Trigger - 문제 상황 발생 시뮬레이션
+"""
+
+import os
+import sys
+import requests
+import json
+import random
+from datetime import datetime, timedelta
+
+HF_SPACE_URL = os.environ.get('HF_SPACE_URL')
+API_KEY = os.environ.get('INTERNAL_API_KEY')
+
+def get_issue_config(issue_type, station_id=None):
+    """문제 유형별 설정 생성"""
+    
+    configs = {
+        'network_failure': {
+            'description': 'Network connectivity issues',
+            'duration_seconds': random.randint(30, 120),
+            'failure_rate': random.uniform(0.7, 0.9),
+            'affected_endpoints': ['/api/internal/collect_data', '/api/internal/update_predictions'],
+            'recovery_time': random.randint(15, 45),
+            'symptoms': ['timeout errors', 'connection refused', 'partial data loss']
+        },
+        
+        'extreme_weather': {
+            'description': 'Extreme weather conditions (typhoon simulation)',
+            'magnitude': random.choice(['moderate', 'high', 'severe']),
+            'duration_minutes': random.randint(60, 180),
+            'affected_parameters': {
+                'tide_level': {'offset': random.randint(150, 400), 'noise_factor': 3.0},
+                'wind_speed': {'multiplier': random.uniform(2.5, 5.0)},
+                'air_pres': {'offset': random.randint(-30, -15)},
+                'wind_dir': {'chaos_factor': 0.8}  # 풍향 불안정
+            },
+            'warning_threshold': 750.0,  # cm
+            'danger_threshold': 900.0
+        },
+        
+        'sensor_malfunction': {
+            'description': f'Sensor malfunction at station {station_id or "random"}',
+            'target_station': station_id or random.choice(['DT_0001', 'DT_0002', 'DT_0003']),
+            'malfunction_type': random.choice(['data_loss', 'frozen_values', 'random_noise', 'calibration_drift']),
+            'affected_sensors': random.sample(['tide_level', 'air_temp', 'air_pres', 'wind_speed'], 
+                                            random.randint(1, 3)),
+            'duration_minutes': random.randint(30, 90),
+            'recovery_probability': 0.8
+        },
+        
+        'data_corruption': {
+            'description': 'Data transmission corruption',
+            'corruption_rate': random.uniform(0.1, 0.4),
+            'corruption_types': ['missing_fields', 'invalid_values', 'timestamp_errors', 'encoding_issues'],
+            'affected_stations': random.sample(['DT_0001', 'DT_0002', 'DT_0003', 'DT_0008', 'DT_0017'], 
+                                             random.randint(2, 4)),
+            'duration_minutes': random.randint(15, 60)
+        }
+    }
+    
+    return configs.get(issue_type, {})
+
+def trigger_issue(issue_type, station_id=None):
+    """문제 상황 발생"""
+    
+    if not HF_SPACE_URL or not API_KEY:
+        print("❌ Missing environment variables")
+        sys.exit(1)
+    
+    print(f"⚠️ Triggering issue: {issue_type}")
+    if station_id:
+        print(f"🎯 Target station: {station_id}")
+    
+    # 문제 설정 생성
+    issue_config = get_issue_config(issue_type, station_id)
+    
+    if not issue_config:
+        print(f"❌ Unknown issue type: {issue_type}")
+        print("Available types: network_failure, extreme_weather, sensor_malfunction, data_corruption")
+        sys.exit(1)
+    
+    # API 페이로드 구성
+    payload = {
+        'action': 'trigger_issue',
+        'issue_type': issue_type,
+        'station_id': station_id,
+        'timestamp': datetime.now().isoformat(),
+        'severity': 'demo',
+        'config': issue_config,
+        'auto_recovery': True,  # 자동 복구 활성화
+        'notification': True    # 알림 활성화
+    }
+    
+    # 문제 유형별 특별 처리
+    if issue_type == 'network_failure':
+        print(f"🌐 Simulating network failure for {issue_config['duration_seconds']} seconds")
+        print(f"📊 Failure rate: {issue_config['failure_rate']:.1%}")
+        
+    elif issue_type == 'extreme_weather':
+        magnitude = issue_config['magnitude']
+        duration = issue_config['duration_minutes']
+        print(f"🌪️ Simulating {magnitude} extreme weather for {duration} minutes")
+        print(f"🌊 Expected tide surge: +{issue_config['affected_parameters']['tide_level']['offset']} cm")
+        
+    elif issue_type == 'sensor_malfunction':
+        target = issue_config['target_station']
+        malfunction = issue_config['malfunction_type']
+        sensors = issue_config['affected_sensors']
+        print(f"🔧 Simulating {malfunction} at {target}")
+        print(f"📡 Affected sensors: {', '.join(sensors)}")
+        
+    elif issue_type == 'data_corruption':
+        rate = issue_config['corruption_rate']
+        stations = issue_config['affected_stations']
+        print(f"🔀 Simulating data corruption ({rate:.1%} rate)")
+        print(f"🏪 Affected stations: {', '.join(stations)}")
+    
+    try:
+        print("🚀 Sending issue trigger to HF Space...")
+        
+        response = requests.post(
+            f"{HF_SPACE_URL}/api/internal/trigger_demo",
+            headers={
+                'Authorization': f'Bearer {API_KEY}',
+                'Content-Type': 'application/json'
+            },
+            json=payload,
+            timeout=30
+        )
+        
+        if response.status_code == 200:
+            result = response.json()
+            print("✅ Issue triggered successfully!")
+            
+            print("\n📊 Issue Details:")
+            print(f"   🎯 Target: {result.get('target', 'system-wide')}")
+            print(f"   ⏱️ Duration: {result.get('expected_duration', 'variable')}")
+            print(f"   📈 Expected impact: {result.get('expected_impact', 'monitoring required')}")
+            print(f"   🔄 Auto recovery: {result.get('auto_recovery', 'enabled')}")
+            
+            if 'issue_id' in result:
+                print(f"   🆔 Issue ID: {result['issue_id']}")
+            
+            # 모니터링 권장사항
+            print("\n🔍 Monitoring recommendations:")
+            if issue_type == 'network_failure':
+                print("   - Watch for API timeout errors")
+                print("   - Monitor data collection success rate")
+                print("   - Check system health dashboard")
+                
+            elif issue_type == 'extreme_weather':
+                print("   - Monitor tide level predictions")
+                print("   - Watch for alert threshold breaches")
+                print("   - Check RMSE increase")
+                
+            elif issue_type == 'sensor_malfunction':
+                print(f"   - Monitor {issue_config['target_station']} data quality")
+                print("   - Watch for missing data warnings")
+                print("   - Check interpolation accuracy")
+                
+            elif issue_type == 'data_corruption':
+                print("   - Monitor data validation errors")
+                print("   - Check processing success rate")
+                print("   - Watch for data quality alerts")
+            
+            # 결과 저장
+            with open(f'issue_trigger_{issue_type}_{datetime.now().strftime("%H%M%S")}.json', 'w') as f:
+                json.dump(result, f, indent=2)
+                
+        else:
+            print(f"❌ Failed to trigger issue: {response.status_code}")
+            print(f"Response: {response.text}")
+            
+            # 에러 상세 정보
+            try:
+                error_detail = response.json()
+                if 'detail' in error_detail:
+                    print(f"Error detail: {error_detail['detail']}")
+            except:
+                pass
+                
+            sys.exit(1)
+            
+    except requests.exceptions.Timeout:
+        print("⏱️ Request timed out (this might be part of network failure simulation)")
+        if issue_type == 'network_failure':
+            print("✅ Network failure simulation appears to be working!")
+        else:
+            sys.exit(1)
+            
+    except Exception as e:
+        print(f"❌ Error triggering issue: {e}")
+        sys.exit(1)
+
+def list_available_issues():
+    """사용 가능한 문제 유형 목록"""
+    
+    issues = {
+        'network_failure': 'Network connectivity problems, API timeouts',
+        'extreme_weather': 'Typhoon/storm simulation with extreme tide levels',
+        'sensor_malfunction': 'Individual station sensor failures',
+        'data_corruption': 'Data transmission and validation errors'
+    }
+    
+    print("🔧 Available issue types:")
+    for issue_type, description in issues.items():
+        print(f"   {issue_type}: {description}")
+
+if __name__ == '__main__':
+    if len(sys.argv) < 2:
+        print("Usage: python trigger_issue.py <issue_type> [station_id]")
+        print()
+        list_available_issues()
+        print()
+        print("Examples:")
+        print("  python trigger_issue.py network_failure")
+        print("  python trigger_issue.py extreme_weather")
+        print("  python trigger_issue.py sensor_malfunction DT_0001")
+        print("  python trigger_issue.py data_corruption")
+        sys.exit(1)
+    
+    issue_type = sys.argv[1]
+    station_id = sys.argv[2] if len(sys.argv) > 2 else None
+    
+    if issue_type == 'list':
+        list_available_issues()
+        sys.exit(0)
+    
+    print(f"🎭 Starting issue simulation: {issue_type}")
+    print(f"🕐 Current time: {datetime.now().isoformat()}")
+    
+    trigger_issue(issue_type, station_id)

.github/workflows/tide_scheduler.yml

@@ -1,122 +1,113 @@
-name: Tide Data Automation
+name: Tide Data Interactive Demo
 
 on:
-  schedule:
-    # 5분마다 데이터 수집 및 처리
-    - cron: '*/5 * * * *'
-  
-  workflow_dispatch:  # 수동 실행 옵션
+  # 자동 스케줄링 제거 - 완전 수동 제어
+  workflow_dispatch:  # 수동 실행만 지원
     inputs:
-      task_type:
-        description: 'Task to run'
+      demo_action:
+        description: 'Demo action to perform'
         required: true
-        default: 'all'
+        default: 'start_demo'
+        type: choice
+        options:
+          - start_demo           # 시연 시작
+          - stop_demo           # 시연 중지
+          - send_data_batch     # 데이터 배치 전송
+          - trigger_issue       # 문제 상황 발생
+          - system_recovery     # 시스템 복구
+          - health_check        # 상태 체크
+      
+      issue_type:
+        description: 'Type of issue to simulate'
+        required: false
+        default: 'network_failure'
         type: choice
         options:
-          - all
-          - collect_data
-          - update_predictions
+          - network_failure     # 네트워크 장애
+          - extreme_weather     # 극값 데이터
+          - sensor_malfunction  # 센서 고장
+          - data_corruption     # 데이터 손상
+      
+      station_id:
+        description: 'Target station for issue (optional)'
+        required: false
+        default: 'DT_0001'
+        type: string
+      
+      batch_size:
+        description: 'Number of data points to send'
+        required: false
+        default: '12'  # 1시간분 (5분 간격)
+        type: string
 
 env:
   HF_SPACE_URL: https://alwaysgood-my-tide-env.hf.space
   
 jobs:
-  collect_and_process:
+  # 시연 제어 작업
+  demo_controller:
     runs-on: ubuntu-latest
-    timeout-minutes: 5
+    timeout-minutes: 15
     
     steps:
-      - name: Check current time
-        id: time_check
-        run: |
-          MINUTE=$(date +%M)
-          echo "current_minute=$MINUTE" >> $GITHUB_OUTPUT
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        
+      - name: Setup Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.9'
           
-          # 10분 단위 체크
-          if [ $((MINUTE % 10)) -eq 0 ]; then
-            echo "should_predict=true" >> $GITHUB_OUTPUT
-          else
-            echo "should_predict=false" >> $GITHUB_OUTPUT
-          fi
-      
-      - name: Collect and Process Data (5분 간격)
+      - name: Install dependencies
         run: |
-          response=$(curl -X POST "${{ env.HF_SPACE_URL }}/api/internal/collect_data" \
-            -H "Authorization: Bearer ${{ secrets.INTERNAL_API_KEY }}" \
-            -H "Content-Type: application/json" \
-            -d '{
-              "task": "collect_and_process",
-              "timestamp": "'$(date -u +%Y-%m-%dT%H:%M:%S)'"
-            }' \
-            -w "\n%{http_code}" \
-            -s)
-          
-          http_code=$(echo "$response" | tail -n1)
-          body=$(echo "$response" | head -n-1)
-          
-          if [ "$http_code" != "200" ]; then
-            echo "❌ Data collection failed with status $http_code"
-            echo "Response: $body"
-            exit 1
-          fi
-          
-          echo "✅ Data collection successful"
-          echo "$body" | jq '.'
+          pip install pandas numpy requests python-dateutil
       
-      - name: Update Predictions (10분 간격)
-        if: steps.time_check.outputs.should_predict == 'true'
+      - name: Execute demo action
         run: |
-          response=$(curl -X POST "${{ env.HF_SPACE_URL }}/api/internal/update_predictions" \
-            -H "Authorization: Bearer ${{ secrets.INTERNAL_API_KEY }}" \
-            -H "Content-Type: application/json" \
-            -d '{
-              "task": "update_predictions",
-              "timestamp": "'$(date -u +%Y-%m-%dT%H:%M:%S)'"
-            }' \
-            -w "\n%{http_code}" \
-            -s)
+          ACTION="${{ github.event.inputs.demo_action }}"
+          echo "🎬 Executing demo action: $ACTION"
           
-          http_code=$(echo "$response" | tail -n1)
-          body=$(echo "$response" | head -n-1)
+          case $ACTION in
+            "start_demo")
+              echo "🚀 Starting interactive demo..."
+              python3 .github/scripts/demo_controller.py start
+              ;;
+            "stop_demo")
+              echo "🛑 Stopping demo..."
+              python3 .github/scripts/demo_controller.py stop
+              ;;
+            "send_data_batch")
+              echo "📦 Sending data batch..."
+              python3 .github/scripts/send_data_batch.py
+              ;;
+            "trigger_issue")
+              echo "⚠️ Triggering issue: ${{ github.event.inputs.issue_type }}"
+              python3 .github/scripts/trigger_issue.py "${{ github.event.inputs.issue_type }}" "${{ github.event.inputs.station_id }}"
+              ;;
+            "system_recovery")
+              echo "🔧 Initiating system recovery..."
+              python3 .github/scripts/system_recovery.py
+              ;;
+            "health_check")
+              echo "🏥 Performing health check..."
+              python3 .github/scripts/health_check.py
+              ;;
+            *)
+              echo "❌ Unknown action: $ACTION"
+              exit 1
+              ;;
+          esac
           
-          if [ "$http_code" != "200" ]; then
-            echo "❌ Prediction update failed with status $http_code"
-            echo "Response: $body"
-            exit 1
-          fi
-          
-          echo "✅ Predictions updated successfully"
-          echo "$body" | jq '.'
-      
-      - name: Send notification on failure
-        if: failure()
-        run: |
-          # Slack, Discord, 또는 이메일 알림 전송
-          echo "Pipeline failed at $(date)"
-          # curl -X POST slack_webhook_url ...
-
-  health_check:
-    runs-on: ubuntu-latest
-    needs: collect_and_process
-    
-    steps:
-      - name: Verify System Health
-        run: |
-          response=$(curl -s "${{ env.HF_SPACE_URL }}/api/health")
-          echo "$response" | jq '.'
-          
-          status=$(echo "$response" | jq -r '.status')
-          if [ "$status" != "healthy" ]; then
-            echo "⚠️ System is not healthy: $status"
-          fi
-      
-      - name: Check Data Freshness
+      - name: Save execution results
         run: |
-          response=$(curl -s "${{ env.HF_SPACE_URL }}/api/internal/data_freshness")
-          echo "$response" | jq '.'
+          # 실행 결과를 아티팩트로 저장
+          mkdir -p demo_results
+          echo "$(date): ${{ github.event.inputs.demo_action }} completed" >> demo_results/execution_log.txt
+          echo "Parameters: issue_type=${{ github.event.inputs.issue_type }}, station=${{ github.event.inputs.station_id }}" >> demo_results/execution_log.txt
           
-          # 데이터가 15분 이상 오래된 경우 경고
-          minutes_old=$(echo "$response" | jq -r '.oldest_data_minutes')
-          if [ "$minutes_old" -gt 15 ]; then
-            echo "⚠️ Data is stale: ${minutes_old} minutes old"
-          fi
+      - name: Upload demo results
+        uses: actions/upload-artifact@v3
+        with:
+          name: demo-execution-results
+          path: demo_results/
+          retention-days: 7

automation/data_collector.py

@@ -1,176 +0,0 @@
-"""
-데이터 수집 모듈
-공공 API에서 실시간 조위 데이터 수집
-"""
-
-import aiohttp
-import asyncio
-from datetime import datetime, timedelta
-import pandas as pd
-import numpy as np
-from typing import Dict, List, Optional
-import logging
-from config import STATIONS, KHOA_API_KEY
-
-logger = logging.getLogger(__name__)
-
-class DataCollector:
-    """실시간 조위 데이터 수집기"""
-    
-    def __init__(self):
-        self.api_base_url = "http://www.khoa.go.kr/api/oceangrid/tideObsRecent/search.do"
-        self.api_key = KHOA_API_KEY  # 환경변수로 관리
-        self.stations = STATIONS
-        
-    async def collect_station_data(self, station_id: str) -> Dict:
-        """단일 관측소 데이터 수집"""
-        
-        params = {
-            "ServiceKey": self.api_key,
-            "ObsCode": station_id,
-            "ResultType": "json",
-            "DataType": "tideObs",  # 실시간 관측 데이터
-        }
-        
-        try:
-            async with aiohttp.ClientSession() as session:
-                async with session.get(self.api_base_url, params=params, timeout=30) as response:
-                    if response.status == 200:
-                        data = await response.json()
-                        
-                        # 데이터 파싱
-                        if data.get("result", {}).get("data"):
-                            observations = data["result"]["data"]
-                            
-                            # 최신 데이터만 추출
-                            latest_obs = observations[0] if observations else None
-                            
-                            if latest_obs:
-                                return {
-                                    "station_id": station_id,
-                                    "observed_at": latest_obs.get("record_time"),
-                                    "tide_level": float(latest_obs.get("tide_level", 0)),
-                                    "air_temp": float(latest_obs.get("air_temp", 0)),
-                                    "water_temp": float(latest_obs.get("water_temp", 0)),
-                                    "air_pres": float(latest_obs.get("air_press", 1013)),
-                                    "wind_dir": float(latest_obs.get("wind_dir", 0)),
-                                    "wind_speed": float(latest_obs.get("wind_speed", 0)),
-                                    "status": "success"
-                                }
-                    
-                    logger.warning(f"Failed to collect data for {station_id}: Status {response.status}")
-                    return {"station_id": station_id, "status": "failed", "error": f"HTTP {response.status}"}
-                    
-        except asyncio.TimeoutError:
-            logger.error(f"Timeout collecting data for {station_id}")
-            return {"station_id": station_id, "status": "timeout"}
-        except Exception as e:
-            logger.error(f"Error collecting data for {station_id}: {str(e)}")
-            return {"station_id": station_id, "status": "error", "error": str(e)}
-    
-    async def collect_all_stations(self) -> List[Dict]:
-        """모든 관측소 데이터 병렬 수집"""
-        
-        tasks = [
-            self.collect_station_data(station_id) 
-            for station_id in self.stations
-        ]
-        
-        results = await asyncio.gather(*tasks)
-        
-        # 성공한 데이터만 필터링
-        valid_results = [r for r in results if r.get("status") == "success"]
-        
-        logger.info(f"Collected data from {len(valid_results)}/{len(self.stations)} stations")
-        
-        return valid_results
-    
-    async def collect_with_retry(self, max_retries: int = 3) -> List[Dict]:
-        """재시도 로직을 포함한 데이터 수집"""
-        
-        all_data = []
-        failed_stations = list(self.stations)
-        
-        for attempt in range(max_retries):
-            if not failed_stations:
-                break
-                
-            logger.info(f"Collection attempt {attempt + 1}/{max_retries} for {len(failed_stations)} stations")
-            
-            tasks = [
-                self.collect_station_data(station_id) 
-                for station_id in failed_stations
-            ]
-            
-            results = await asyncio.gather(*tasks)
-            
-            # 성공/실패 분류
-            newly_succeeded = []
-            still_failed = []
-            
-            for result in results:
-                if result.get("status") == "success":
-                    newly_succeeded.append(result)
-                else:
-                    still_failed.append(result["station_id"])
-            
-            all_data.extend(newly_succeeded)
-            failed_stations = still_failed
-            
-            if failed_stations and attempt < max_retries - 1:
-                # 재시도 전 대기
-                await asyncio.sleep(2 ** attempt)  # Exponential backoff
-        
-        if failed_stations:
-            logger.warning(f"Failed to collect data from stations: {failed_stations}")
-        
-        return all_data
-    
-    def validate_data(self, data: Dict) -> bool:
-        """데이터 유효성 검증"""
-        
-        # 필수 필드 확인
-        required_fields = ["station_id", "observed_at", "tide_level"]
-        if not all(field in data for field in required_fields):
-            return False
-        
-        # 범위 검증
-        tide_level = data.get("tide_level", 0)
-        if not -100 <= tide_level <= 1000:  # cm 단위
-            logger.warning(f"Invalid tide level: {tide_level} for station {data['station_id']}")
-            return False
-        
-        # 시간 검증 (너무 오래된 데이터 제외)
-        try:
-            obs_time = datetime.fromisoformat(data["observed_at"])
-            if (datetime.now() - obs_time).total_seconds() > 3600:  # 1시간 이상 오래된 데이터
-                logger.warning(f"Stale data for station {data['station_id']}: {data['observed_at']}")
-                return False
-        except:
-            return False
-        
-        return True
-
-
-class MockDataCollector(DataCollector):
-    """테스트용 모의 데이터 수집기"""
-    
-    async def collect_station_data(self, station_id: str) -> Dict:
-        """모의 데이터 생성"""
-        
-        # 실제 API 대신 랜덤 데이터 생성
-        import random
-        
-        base_tide = 300 + 200 * np.sin(datetime.now().timestamp() / 3600 * np.pi / 6)
-        
-        return {
-            "station_id": station_id,
-            "observed_at": datetime.now().isoformat(),
-            "tide_level": base_tide + random.uniform(-10, 10),
-            "air_temp": 20 + random.uniform(-5, 5),
-            "water_temp": 18 + random.uniform(-3, 3),
-            "air_pres": 1013 + random.uniform(-10, 10),
-            "wind_dir": random.uniform(0, 360),
-            "wind_speed": random.uniform(0, 20),
-            "status": "success"
-        }

automation/data_processor.py

@@ -1,279 +0,0 @@
-"""
-데이터 처리 모듈
-수집된 데이터의 결측치 처리, 리샘플링, 저장
-"""
-
-import pandas as pd
-import numpy as np
-from datetime import datetime, timedelta
-from scipy import interpolate
-from typing import List, Dict, Optional
-import logging
-from supabase_utils import get_supabase_client
-from config import DATA_COLLECTION_CONFIG
-
-logger = logging.getLogger(__name__)
-
-class DataProcessor:
-    """데이터 처리 및 저장 클래스"""
-    
-    def __init__(self):
-        self.client = get_supabase_client()
-        self.resample_interval = DATA_COLLECTION_CONFIG["resample_interval"]
-        self.missing_threshold = DATA_COLLECTION_CONFIG["missing_threshold_minutes"]
-    
-    async def process_data(self, raw_data: List[Dict]) -> pd.DataFrame:
-        """원시 데이터 처리"""
-        
-        if not raw_data:
-            logger.warning("No data to process")
-            return pd.DataFrame()
-        
-        # DataFrame으로 변환
-        df = pd.DataFrame(raw_data)
-        df['observed_at'] = pd.to_datetime(df['observed_at'])
-        df.set_index('observed_at', inplace=True)
-        
-        # 관측소별로 처리
-        processed_frames = []
-        
-        for station_id in df['station_id'].unique():
-            station_data = df[df['station_id'] == station_id].copy()
-            
-            # 1. 결측치 처리
-            station_data = self.handle_missing_values(station_data)
-            
-            # 2. 이상치 제거
-            station_data = self.remove_outliers(station_data)
-            
-            # 3. 5분 리샘플링
-            station_data = self.resample_data(station_data)
-            
-            # 4. Residual 계산
-            station_data = self.calculate_residual(station_data, station_id)
-            
-            processed_frames.append(station_data)
-        
-        # 모든 관측소 데이터 결합
-        if processed_frames:
-            result = pd.concat(processed_frames, ignore_index=True)
-            return result
-        
-        return pd.DataFrame()
-    
-    def handle_missing_values(self, df: pd.DataFrame) -> pd.DataFrame:
-        """결측치 처리 - 10분 미만은 코사인 보간"""
-        
-        for column in ['tide_level', 'air_temp', 'air_pres', 'wind_speed', 'wind_dir']:
-            if column not in df.columns:
-                continue
-                
-            # 결측치 찾기
-            missing_mask = df[column].isna()
-            
-            if not missing_mask.any():
-                continue
-            
-            # 연속된 결측치 그룹 찾기
-            missing_groups = self.find_missing_groups(missing_mask)
-            
-            for start_idx, end_idx in missing_groups:
-                duration_minutes = (df.index[end_idx] - df.index[start_idx]).total_seconds() / 60
-                
-                if duration_minutes < self.missing_threshold:
-                    # 10분 미만: 코사인 보간 (조위 특성 반영)
-                    if column == 'tide_level':
-                        df[column] = self.cosine_interpolation(df[column], start_idx, end_idx)
-                    else:
-                        # 다른 기상 데이터는 선형 보간
-                        df[column].interpolate(method='linear', inplace=True)
-                else:
-                    # 10분 이상: 예측값 사용 (별도 처리 필요)
-                    logger.warning(f"Long missing period ({duration_minutes:.1f} min) for {column}")
-                    # 일단 forward fill 사용
-                    df[column].fillna(method='ffill', inplace=True)
-        
-        return df
-    
-    def cosine_interpolation(self, series: pd.Series, start_idx: int, end_idx: int) -> pd.Series:
-        """코사인 보간 (조위의 주기적 특성 반영)"""
-        
-        # 유효한 데이터 포인트
-        valid_mask = ~series.isna()
-        valid_indices = np.where(valid_mask)[0]
-        
-        if len(valid_indices) < 2:
-            return series
-        
-        # PCHIP 보간 (Piecewise Cubic Hermite Interpolating Polynomial)
-        # 부드러운 곡선을 생성하며 오버슈팅을 방지
-        interp_func = interpolate.PchipInterpolator(
-            valid_indices,
-            series.iloc[valid_indices].values,
-            extrapolate=False
-        )
-        
-        # 결측 구간 보간
-        missing_indices = np.arange(start_idx, end_idx + 1)
-        interpolated_values = interp_func(missing_indices)
-        
-        # 결과 적용
-        result = series.copy()
-        result.iloc[missing_indices] = interpolated_values
-        
-        return result
-    
-    def find_missing_groups(self, missing_mask: pd.Series) -> List[tuple]:
-        """연속된 결측치 그룹 찾기"""
-        
-        groups = []
-        in_group = False
-        start_idx = 0
-        
-        for i, is_missing in enumerate(missing_mask):
-            if is_missing and not in_group:
-                start_idx = i
-                in_group = True
-            elif not is_missing and in_group:
-                groups.append((start_idx, i - 1))
-                in_group = False
-        
-        if in_group:
-            groups.append((start_idx, len(missing_mask) - 1))
-        
-        return groups
-    
-    def remove_outliers(self, df: pd.DataFrame) -> pd.DataFrame:
-        """이상치 제거"""
-        
-        # Z-score 방법
-        for column in ['tide_level', 'air_temp', 'air_pres']:
-            if column not in df.columns:
-                continue
-                
-            z_scores = np.abs((df[column] - df[column].mean()) / df[column].std())
-            
-            # Z-score > 4인 경우 이상치로 판단
-            outlier_mask = z_scores > 4
-            
-            if outlier_mask.any():
-                logger.info(f"Removing {outlier_mask.sum()} outliers from {column}")
-                df.loc[outlier_mask, column] = np.nan
-                # 이상치는 선형 보간으로 대체
-                df[column].interpolate(method='linear', inplace=True)
-        
-        # 물리적 범위 체크
-        if 'tide_level' in df.columns:
-            df.loc[df['tide_level'] < -100, 'tide_level'] = np.nan
-            df.loc[df['tide_level'] > 1000, 'tide_level'] = np.nan
-            df['tide_level'].interpolate(method='linear', inplace=True)
-        
-        return df
-    
-    def resample_data(self, df: pd.DataFrame) -> pd.DataFrame:
-        """5분 간격으로 리샘플링"""
-        
-        # 시계열 인덱스 확인
-        if not isinstance(df.index, pd.DatetimeIndex):
-            df.index = pd.to_datetime(df.index)
-        
-        # 5분 평균으로 리샘플링
-        numeric_columns = df.select_dtypes(include=[np.number]).columns
-        resampled = df[numeric_columns].resample(self.resample_interval).mean()
-        
-        # 카테고리 데이터는 최빈값
-        categorical_columns = df.select_dtypes(exclude=[np.number]).columns
-        for col in categorical_columns:
-            if col in df.columns:
-                resampled[col] = df[col].resample(self.resample_interval).agg(lambda x: x.mode()[0] if not x.empty else None)
-        
-        # station_id 복원
-        if 'station_id' not in resampled.columns and 'station_id' in df.columns:
-            resampled['station_id'] = df['station_id'].iloc[0]
-        
-        return resampled.reset_index()
-    
-    def calculate_residual(self, df: pd.DataFrame, station_id: str) -> pd.DataFrame:
-        """잔차 계산 (관측값 - 조화예측값)"""
-        
-        # 조화 예측값 가져오기 (별도 구현 필요)
-        # 여기서는 간단한 예시
-        df['astronomical_tide'] = self.get_astronomical_tide(station_id, df.index)
-        
-        if 'tide_level' in df.columns:
-            df['residual'] = df['tide_level'] - df['astronomical_tide']
-        else:
-            df['residual'] = 0
-        
-        return df
-    
-    def get_astronomical_tide(self, station_id: str, timestamps: pd.DatetimeIndex) -> np.ndarray:
-        """조화 예측값 계산 (간단한 예시)"""
-        
-        # 실제로는 조화 상수를 사용한 계산 필요
-        # 여기서는 간단한 사인 함수로 대체
-        hours = timestamps.hour + timestamps.minute / 60
-        
-        # 주요 조석 성분 (M2: 12.42시간 주기)
-        M2_period = 12.42
-        tide = 200 * np.sin(2 * np.pi * hours / M2_period)
-        
-        # 평균 해수면 높이 추가
-        tide += 300
-        
-        return tide
-    
-    async def save_to_database(self, df: pd.DataFrame) -> int:
-        """처리된 데이터를 Supabase에 저장"""
-        
-        if df.empty:
-            return 0
-        
-        # 저장할 데이터 준비
-        records = []
-        for _, row in df.iterrows():
-            record = {
-                "station_id": row.get("station_id"),
-                "observed_at": row.get("observed_at").isoformat() if pd.notna(row.get("observed_at")) else None,
-                "tide_level": float(row.get("tide_level", 0)),
-                "astronomical_tide": float(row.get("astronomical_tide", 0)),
-                "residual": float(row.get("residual", 0)),
-                "air_temp": float(row.get("air_temp", 0)),
-                "air_pres": float(row.get("air_pres", 1013)),
-                "wind_dir": float(row.get("wind_dir", 0)),
-                "wind_speed": float(row.get("wind_speed", 0)),
-                "interpolated": False,  # 보간 여부
-                "created_at": datetime.now().isoformat()
-            }
-            records.append(record)
-        
-        try:
-            # Supabase에 저장
-            response = self.client.table("tide_observations_processed").insert(records).execute()
-            
-            logger.info(f"Saved {len(records)} records to database")
-            return len(records)
-            
-        except Exception as e:
-            logger.error(f"Failed to save data: {str(e)}")
-            return 0
-    
-    async def cleanup_old_data(self, days_to_keep: int = 7) -> int:
-        """오래된 원시 데이터 정리"""
-        
-        cutoff_date = datetime.now() - timedelta(days=days_to_keep)
-        
-        try:
-            # 오래된 데이터 삭제
-            response = self.client.table("tide_observations_raw").delete().lt(
-                "created_at", cutoff_date.isoformat()
-            ).execute()
-            
-            deleted_count = len(response.data) if response.data else 0
-            logger.info(f"Cleaned up {deleted_count} old records")
-            
-            return deleted_count
-            
-        except Exception as e:
-            logger.error(f"Cleanup failed: {str(e)}")
-            return 0

automation/internal_api.py

@@ -1,174 +0,0 @@
-"""
-Internal API endpoints for automation
-GitHub Actions에서 호출하는 내부 API
-"""
-
-from fastapi import FastAPI, HTTPException, Header, Request
-from datetime import datetime, timedelta
-import os
-import asyncio
-from typing import Optional
-import logging
-from config import INTERNAL_API_KEY
-
-logger = logging.getLogger(__name__)
-
-# 환경변수에서 내부 API 키 가져오기
-INTERNAL_API_KEY = os.getenv("INTERNAL_API_KEY", "")
-
-def verify_internal_api_key(authorization: str = Header(None)):
-    """내부 API 키 검증"""
-    if not authorization or authorization != f"Bearer {INTERNAL_API_KEY}":
-        raise HTTPException(status_code=401, detail="Unauthorized")
-    return True
-
-def register_internal_routes(app: FastAPI):
-    """FastAPI 앱에 내부 API 라우트 등록"""
-    
-    @app.post("/api/internal/collect_data", tags=["Internal"])
-    async def collect_data_endpoint(
-        request: Request,
-        authorization: str = Header(None)
-    ):
-        """데이터 수집 및 처리 엔드포인트"""
-        verify_internal_api_key(authorization)
-        
-        try:
-            # 데이터 수집 작업 시작
-            from automation.data_collector import DataCollector
-            from automation.data_processor import DataProcessor
-            
-            collector = DataCollector()
-            processor = DataProcessor()
-            
-            # 1. 모든 관측소 데이터 수집
-            collected_data = await collector.collect_all_stations()
-            
-            # 2. 데이터 처리 (결측치 처리, 리샘플링)
-            processed_data = await processor.process_data(collected_data)
-            
-            # 3. Supabase 저장
-            saved_count = await processor.save_to_database(processed_data)
-            
-            return {
-                "success": True,
-                "timestamp": datetime.now().isoformat(),
-                "stations_collected": len(collected_data),
-                "records_saved": saved_count,
-                "message": f"Successfully collected and processed data for {len(collected_data)} stations"
-            }
-            
-        except Exception as e:
-            logger.error(f"Data collection failed: {str(e)}")
-            raise HTTPException(status_code=500, detail=str(e))
-    
-    @app.post("/api/internal/update_predictions", tags=["Internal"])
-    async def update_predictions_endpoint(
-        request: Request,
-        authorization: str = Header(None)
-    ):
-        """예측 업데이트 엔드포인트"""
-        verify_internal_api_key(authorization)
-        
-        try:
-            from automation.prediction_updater import PredictionUpdater
-            
-            updater = PredictionUpdater()
-            
-            # 1. 모든 관측소에 대한 예측 업데이트
-            results = await updater.update_all_predictions()
-            
-            return {
-                "success": True,
-                "timestamp": datetime.now().isoformat(),
-                "predictions_updated": results["updated_count"],
-                "stations": results["stations"],
-                "prediction_horizon": "72 hours",
-                "message": f"Successfully updated predictions for {results['updated_count']} stations"
-            }
-            
-        except Exception as e:
-            logger.error(f"Prediction update failed: {str(e)}")
-            raise HTTPException(status_code=500, detail=str(e))
-    
-    @app.get("/api/internal/data_freshness", tags=["Internal"])
-    async def check_data_freshness(
-        authorization: str = Header(None)
-    ):
-        """데이터 신선도 체크"""
-        verify_internal_api_key(authorization)
-        
-        try:
-            from supabase_utils import get_supabase_client
-            
-            client = get_supabase_client()
-            
-            # 각 관측소의 최신 데이터 시간 확인
-            freshness_report = {}
-            
-            for station_id in ["DT_0001", "DT_0002", "DT_0003", "DT_0004", "DT_0005"]:
-                response = client.table("tide_observations_processed").select("observed_at").eq(
-                    "station_id", station_id
-                ).order("observed_at", desc=True).limit(1).execute()
-                
-                if response.data:
-                    last_update = datetime.fromisoformat(response.data[0]["observed_at"])
-                    minutes_old = (datetime.now() - last_update).total_seconds() / 60
-                    freshness_report[station_id] = {
-                        "last_update": last_update.isoformat(),
-                        "minutes_old": round(minutes_old, 2),
-                        "status": "fresh" if minutes_old < 10 else "stale"
-                    }
-                else:
-                    freshness_report[station_id] = {
-                        "last_update": None,
-                        "minutes_old": None,
-                        "status": "no_data"
-                    }
-            
-            # 가장 오래된 데이터 찾기
-            oldest_minutes = max(
-                [v["minutes_old"] for v in freshness_report.values() if v["minutes_old"]], 
-                default=0
-            )
-            
-            return {
-                "timestamp": datetime.now().isoformat(),
-                "oldest_data_minutes": round(oldest_minutes, 2),
-                "stations": freshness_report,
-                "overall_status": "healthy" if oldest_minutes < 15 else "warning"
-            }
-            
-        except Exception as e:
-            logger.error(f"Freshness check failed: {str(e)}")
-            raise HTTPException(status_code=500, detail=str(e))
-    
-    @app.post("/api/internal/manual_trigger", tags=["Internal"])
-    async def manual_trigger(
-        task: str,
-        authorization: str = Header(None)
-    ):
-        """수동 작업 트리거"""
-        verify_internal_api_key(authorization)
-        
-        if task == "collect_now":
-            # 즉시 데이터 수집 실행
-            result = await collect_data_endpoint(None, authorization)
-            return result
-        elif task == "predict_now":
-            # 즉시 예측 업데이트
-            result = await update_predictions_endpoint(None, authorization)
-            return result
-        elif task == "cleanup":
-            # 오래된 데이터 정리
-            from automation.data_cleaner import cleanup_old_data
-            deleted_count = await cleanup_old_data(days_to_keep=7)
-            return {
-                "success": True,
-                "deleted_records": deleted_count,
-                "message": f"Cleaned up {deleted_count} old records"
-            }
-        else:
-            raise HTTPException(status_code=400, detail=f"Unknown task: {task}")
-    
-    logger.info("Internal API routes registered successfully")

internal_api.py

@@ -0,0 +1,754 @@
+"""
+Extended Internal API endpoints for automation and demo control
+GitHub Actions 및 시연 제어를 위한 확장된 내부 API
+"""
+
+from fastapi import FastAPI, HTTPException, Header, Request, BackgroundTasks
+from datetime import datetime, timedelta
+import os
+import asyncio
+import json
+import uuid
+import numpy as np
+from typing import Optional, List, Dict, Any
+import logging
+from config import INTERNAL_API_KEY
+
+logger = logging.getLogger(__name__)
+
+# 환경변수에서 내부 API 키 가져오기
+INTERNAL_API_KEY = os.getenv("INTERNAL_API_KEY", "")
+
+# 전역 상태 관리
+demo_session = {
+    "active": False,
+    "session_id": None,
+    "start_time": None,
+    "simulation_start_time": None,
+    "active_stations": [],
+    "current_issues": [],
+    "performance_history": [],
+    "total_processed": 0
+}
+
+# 활성 문제 상황들
+active_issues = {}
+
+def verify_internal_api_key(authorization: str = Header(None)):
+    """내부 API 키 검증"""
+    if not authorization or authorization != f"Bearer {INTERNAL_API_KEY}":
+        raise HTTPException(status_code=401, detail="Unauthorized")
+    return True
+
+def register_internal_routes(app: FastAPI):
+    """FastAPI 앱에 확장된 내부 API 라우트 등록"""
+    
+    # ============================================================================
+    # 기존 엔드포인트들 (호환성 유지)
+    # ============================================================================
+    
+    @app.post("/api/internal/collect_data", tags=["Internal"])
+    async def collect_data_endpoint(
+        request: Request,
+        authorization: str = Header(None)
+    ):
+        """데이터 수집 및 처리 엔드포인트 (확장된 버전)"""
+        verify_internal_api_key(authorization)
+        
+        try:
+            # 요청 데이터 파싱
+            request_data = await request.json()
+            task_type = request_data.get('task', 'normal_collection')
+            stations_data = request_data.get('stations_data', [])
+            simulation_time = request_data.get('simulation_time')
+            
+            logger.info(f"Data collection request: {task_type}, {len(stations_data)} records")
+            
+            # 데이터 처리 모듈 동적 임포트
+            try:
+                from data_processor import DataProcessor
+                processor = DataProcessor()
+            except ImportError:
+                # 간단한 처리 로직 사용
+                processor = SimpleDataProcessor()
+            
+            # 배치 데이터 처리
+            if task_type == 'batch_data_collection':
+                processed_count = await process_batch_data(stations_data, simulation_time)
+                
+                # 시연 세션 업데이트
+                if demo_session["active"]:
+                    demo_session["total_processed"] += processed_count
+                
+                return {
+                    "success": True,
+                    "timestamp": datetime.now().isoformat(),
+                    "task_type": task_type,
+                    "records_saved": processed_count,
+                    "stations_processed": len(set(d.get('station_id') for d in stations_data)),
+                    "processing_time_ms": 150,  # 시뮬레이션
+                    "simulation_time": simulation_time
+                }
+            
+            # 일반 데이터 수집 (기존 로직)
+            else:
+                # 실제 외부 API 수집 시뮬레이션
+                collected_data = await simulate_data_collection()
+                processed_data = await processor.process_data(collected_data)
+                saved_count = await processor.save_to_database(processed_data)
+                
+                return {
+                    "success": True,
+                    "timestamp": datetime.now().isoformat(),
+                    "stations_collected": len(collected_data),
+                    "records_saved": saved_count,
+                    "message": f"Successfully collected and processed data for {len(collected_data)} stations"
+                }
+            
+        except Exception as e:
+            logger.error(f"Data collection failed: {str(e)}")
+            raise HTTPException(status_code=500, detail=str(e))
+    
+    @app.post("/api/internal/update_predictions", tags=["Internal"])
+    async def update_predictions_endpoint(
+        request: Request,
+        authorization: str = Header(None)
+    ):
+        """예측 업데이트 엔드포인트 (확장된 버전)"""
+        verify_internal_api_key(authorization)
+        
+        try:
+            request_data = await request.json()
+            demo_mode = request_data.get('demo_mode', False)
+            speed_multiplier = request_data.get('speed_multiplier', 1)
+            
+            # 예측 업데이트 실행
+            if demo_mode:
+                results = await update_demo_predictions(speed_multiplier)
+            else:
+                # 기존 예측 업데이트 로직
+                try:
+                    from prediction_updater import PredictionUpdater
+                    updater = PredictionUpdater()
+                    results = await updater.update_all_predictions()
+                except ImportError:
+                    results = await simulate_prediction_update()
+            
+            return {
+                "success": True,
+                "timestamp": datetime.now().isoformat(),
+                "predictions_updated": results["updated_count"],
+                "stations": results["stations"],
+                "prediction_horizon": "72 points (6 hours)",
+                "demo_mode": demo_mode,
+                "speed_multiplier": speed_multiplier,
+                "message": f"Successfully updated predictions for {results['updated_count']} stations"
+            }
+            
+        except Exception as e:
+            logger.error(f"Prediction update failed: {str(e)}")
+            raise HTTPException(status_code=500, detail=str(e))
+    
+    # ============================================================================
+    # 새로운 시연 제어 엔드포인트들
+    # ============================================================================
+    
+    @app.post("/api/internal/demo_control", tags=["Demo Control"])
+    async def demo_control_endpoint(
+        request: Request,
+        authorization: str = Header(None)
+    ):
+        """시연 제어 (시작/중지)"""
+        verify_internal_api_key(authorization)
+        
+        try:
+            request_data = await request.json()
+            action = request_data.get('action')
+            
+            if action == 'start_demo':
+                return await start_demo_session(request_data)
+            elif action == 'stop_demo':
+                return await stop_demo_session(request_data)
+            else:
+                raise HTTPException(status_code=400, detail=f"Unknown action: {action}")
+                
+        except Exception as e:
+            logger.error(f"Demo control failed: {str(e)}")
+            raise HTTPException(status_code=500, detail=str(e))
+    
+    @app.get("/api/internal/demo_status", tags=["Demo Control"])
+    async def demo_status_endpoint(authorization: str = Header(None)):
+        """시연 상태 조회"""
+        verify_internal_api_key(authorization)
+        
+        try:
+            current_time = datetime.now()
+            
+            if demo_session["active"]:
+                running_minutes = (current_time - demo_session["start_time"]).total_seconds() / 60
+                
+                return {
+                    "demo_active": True,
+                    "session_id": demo_session["session_id"],
+                    "start_time": demo_session["start_time"].isoformat(),
+                    "running_minutes": round(running_minutes, 1),
+                    "simulation_start_time": demo_session["simulation_start_time"],
+                    "current_sim_time": calculate_current_simulation_time(),
+                    "active_stations": len(demo_session["active_stations"]),
+                    "stations_list": demo_session["active_stations"],
+                    "total_processed": demo_session["total_processed"],
+                    "active_issues": len(active_issues),
+                    "current_rmse": get_current_rmse()
+                }
+            else:
+                return {
+                    "demo_active": False,
+                    "last_session_end": demo_session.get("end_time"),
+                    "total_sessions_today": 1  # 간단한 카운터
+                }
+                
+        except Exception as e:
+            logger.error(f"Demo status check failed: {str(e)}")
+            raise HTTPException(status_code=500, detail=str(e))
+    
+    @app.get("/api/internal/simulation_status", tags=["Demo Control"])
+    async def simulation_status_endpoint(authorization: str = Header(None)):
+        """시뮬레이션 시간 상태"""
+        verify_internal_api_key(authorization)
+        
+        try:
+            current_sim_time = calculate_current_simulation_time()
+            
+            return {
+                "demo_active": demo_session["active"],
+                "current_simulation_time": current_sim_time,
+                "simulation_start_time": demo_session["simulation_start_time"],
+                "real_start_time": demo_session["start_time"].isoformat() if demo_session["start_time"] else None,
+                "elapsed_real_minutes": calculate_elapsed_real_minutes(),
+                "simulation_speed": 1  # 현재는 1:1 비율
+            }
+            
+        except Exception as e:
+            logger.error(f"Simulation status check failed: {str(e)}")
+            raise HTTPException(status_code=500, detail=str(e))
+    
+    @app.post("/api/internal/trigger_demo", tags=["Demo Control"])
+    async def trigger_demo_issue(
+        request: Request,
+        authorization: str = Header(None)
+    ):
+        """시연용 문제 상황 발생"""
+        verify_internal_api_key(authorization)
+        
+        try:
+            request_data = await request.json()
+            issue_type = request_data.get('issue_type')
+            issue_config = request_data.get('config', {})
+            station_id = request_data.get('station_id')
+            
+            logger.info(f"Triggering demo issue: {issue_type}")
+            
+            # 문제 상황 활성화
+            issue_id = str(uuid.uuid4())[:8]
+            
+            issue_record = {
+                "id": issue_id,
+                "type": issue_type,
+                "config": issue_config,
+                "station_id": station_id,
+                "start_time": datetime.now(),
+                "active": True,
+                "demo_mode": True
+            }
+            
+            active_issues[issue_id] = issue_record
+            demo_session["current_issues"].append(issue_id)
+            
+            # 문제 유형별 처리
+            response_data = {
+                "success": True,
+                "issue_id": issue_id,
+                "issue_type": issue_type,
+                "timestamp": datetime.now().isoformat(),
+                "target": station_id or "system-wide",
+                "auto_recovery": issue_config.get('auto_recovery', True)
+            }
+            
+            if issue_type == 'network_failure':
+                duration = issue_config.get('duration_seconds', 60)
+                response_data.update({
+                    "expected_duration": f"{duration} seconds",
+                    "expected_impact": "API timeouts, data collection delays"
+                })
+                
+            elif issue_type == 'extreme_weather':
+                magnitude = issue_config.get('magnitude', 'moderate')
+                duration = issue_config.get('duration_minutes', 90)
+                response_data.update({
+                    "expected_duration": f"{duration} minutes",
+                    "expected_impact": f"{magnitude} tide surge, RMSE increase"
+                })
+                
+            elif issue_type == 'sensor_malfunction':
+                target = issue_config.get('target_station', station_id)
+                sensors = issue_config.get('affected_sensors', ['tide_level'])
+                response_data.update({
+                    "target": target,
+                    "expected_duration": "30-90 minutes",
+                    "expected_impact": f"Missing data for {', '.join(sensors)}"
+                })
+                
+            elif issue_type == 'data_corruption':
+                rate = issue_config.get('corruption_rate', 0.2)
+                response_data.update({
+                    "expected_duration": "15-60 minutes",
+                    "expected_impact": f"{rate:.1%} data corruption rate"
+                })
+            
+            # 자동 복구 스케줄링
+            if issue_config.get('auto_recovery', True):
+                asyncio.create_task(schedule_auto_recovery(issue_id, issue_config))
+            
+            return response_data
+            
+        except Exception as e:
+            logger.error(f"Issue trigger failed: {str(e)}")
+            raise HTTPException(status_code=500, detail=str(e))
+    
+    @app.post("/api/internal/system_recovery", tags=["System Recovery"])
+    async def system_recovery_endpoint(
+        request: Request,
+        authorization: str = Header(None)
+    ):
+        """시스템 복구"""
+        verify_internal_api_key(authorization)
+        
+        try:
+            request_data = await request.json()
+            action = request_data.get('action')
+            
+            if action == 'clear_all_issues':
+                return await clear_all_issues()
+            elif action == 'reset_simulation':
+                return await reset_simulation_state(request_data)
+            else:
+                raise HTTPException(status_code=400, detail=f"Unknown recovery action: {action}")
+                
+        except Exception as e:
+            logger.error(f"System recovery failed: {str(e)}")
+            raise HTTPException(status_code=500, detail=str(e))
+    
+    @app.post("/api/internal/collection_control", tags=["System Recovery"])
+    async def collection_control_endpoint(
+        request: Request,
+        authorization: str = Header(None)
+    ):
+        """데이터 수집 제어"""
+        verify_internal_api_key(authorization)
+        
+        try:
+            request_data = await request.json()
+            action = request_data.get('action')
+            
+            if action == 'start_collection':
+                stations = request_data.get('stations', demo_session["active_stations"])
+                return {
+                    "success": True,
+                    "action": "start_collection",
+                    "active_stations": stations,
+                    "timestamp": datetime.now().isoformat()
+                }
+            elif action == 'stop_collection':
+                return {
+                    "success": True,
+                    "action": "stop_collection",
+                    "timestamp": datetime.now().isoformat()
+                }
+            else:
+                raise HTTPException(status_code=400, detail=f"Unknown collection action: {action}")
+                
+        except Exception as e:
+            logger.error(f"Collection control failed: {str(e)}")
+            raise HTTPException(status_code=500, detail=str(e))
+    
+    # ============================================================================
+    # 기존 엔드포인트들 (호환성 유지)
+    # ============================================================================
+    
+    @app.get("/api/internal/data_freshness", tags=["Internal"])
+    async def check_data_freshness(authorization: str = Header(None)):
+        """데이터 신선도 체크 (확장된 버전)"""
+        verify_internal_api_key(authorization)
+        
+        try:
+            from supabase_utils import get_supabase_client
+            client = get_supabase_client()
+            
+            # 시연용 관측소들
+            demo_stations = demo_session["active_stations"] if demo_session["active"] else [
+                "DT_0001", "DT_0002", "DT_0003", "DT_0008", "DT_0017"
+            ]
+            
+            freshness_report = {}
+            
+            for station_id in demo_stations:
+                try:
+                    response = client.table("tide_observations_processed").select("observed_at").eq(
+                        "station_id", station_id
+                    ).order("observed_at", desc=True).limit(1).execute()
+                    
+                    if response.data:
+                        last_update = datetime.fromisoformat(response.data[0]["observed_at"])
+                        minutes_old = (datetime.now() - last_update).total_seconds() / 60
+                        freshness_report[station_id] = {
+                            "last_update": last_update.isoformat(),
+                            "minutes_old": round(minutes_old, 2),
+                            "status": "fresh" if minutes_old < 10 else "stale"
+                        }
+                    else:
+                        freshness_report[station_id] = {
+                            "last_update": None,
+                            "minutes_old": None,
+                            "status": "no_data"
+                        }
+                except Exception as e:
+                    freshness_report[station_id] = {
+                        "last_update": None,
+                        "minutes_old": None,
+                        "status": "error",
+                        "error": str(e)
+                    }
+            
+            # 가장 오래된 데이터 계산
+            valid_ages = [v["minutes_old"] for v in freshness_report.values() 
+                         if v["minutes_old"] is not None]
+            oldest_minutes = max(valid_ages) if valid_ages else 0
+            
+            return {
+                "timestamp": datetime.now().isoformat(),
+                "oldest_data_minutes": round(oldest_minutes, 2),
+                "stations": freshness_report,
+                "overall_status": "healthy" if oldest_minutes < 15 else "warning",
+                "demo_active": demo_session["active"]
+            }
+            
+        except Exception as e:
+            logger.error(f"Freshness check failed: {str(e)}")
+            raise HTTPException(status_code=500, detail=str(e))
+    
+    @app.post("/api/internal/manual_trigger", tags=["Internal"])
+    async def manual_trigger(
+        task: str,
+        authorization: str = Header(None)
+    ):
+        """수동 작업 트리거 (확장된 버전)"""
+        verify_internal_api_key(authorization)
+        
+        if task == "collect_now":
+            result = await collect_data_endpoint(None, authorization)
+            return result
+        elif task == "predict_now":
+            result = await update_predictions_endpoint(None, authorization)
+            return result
+        elif task == "recovery_mode":
+            return await emergency_recovery()
+        else:
+            raise HTTPException(status_code=400, detail=f"Unknown task: {task}")
+    
+    logger.info("Extended Internal API routes registered successfully")
+
+# ============================================================================
+# 헬퍼 함수들
+# ============================================================================
+
+async def start_demo_session(request_data: dict):
+    """시연 세션 시작"""
+    global demo_session
+    
+    session_id = str(uuid.uuid4())[:8]
+    current_time = datetime.now()
+    sim_start_time = request_data.get('simulation_settings', {}).get('start_time', '2025-07-01T00:00:00')
+    stations = request_data.get('stations', ['DT_0001', 'DT_0002', 'DT_0003', 'DT_0008', 'DT_0017'])
+    
+    demo_session.update({
+        "active": True,
+        "session_id": session_id,
+        "start_time": current_time,
+        "simulation_start_time": sim_start_time,
+        "active_stations": stations,
+        "current_issues": [],
+        "performance_history": [],
+        "total_processed": 0
+    })
+    
+    logger.info(f"Demo session started: {session_id}")
+    
+    return {
+        "success": True,
+        "session_id": session_id,
+        "demo_mode": "interactive",
+        "simulation_start_time": sim_start_time,
+        "stations": stations,
+        "timestamp": current_time.isoformat()
+    }
+
+async def stop_demo_session(request_data: dict):
+    """시연 세션 중지"""
+    global demo_session
+    
+    if not demo_session["active"]:
+        raise HTTPException(status_code=400, detail="No active demo session")
+    
+    end_time = datetime.now()
+    duration_minutes = (end_time - demo_session["start_time"]).total_seconds() / 60
+    
+    # 최종 성능 계산
+    final_rmse = get_current_rmse()
+    final_accuracy = calculate_final_accuracy()
+    
+    session_summary = {
+        "session_id": demo_session["session_id"],
+        "duration_minutes": round(duration_minutes, 1),
+        "total_processed": demo_session["total_processed"],
+        "final_rmse": final_rmse,
+        "final_accuracy": final_accuracy,
+        "issues_encountered": len(demo_session["current_issues"]),
+        "end_time": end_time.isoformat()
+    }
+    
+    # 세션 초기화
+    demo_session.update({
+        "active": False,
+        "session_id": None,
+        "start_time": None,
+        "end_time": end_time.isoformat()
+    })
+    
+    # 활성 문제들 정리
+    global active_issues
+    active_issues.clear()
+    
+    logger.info(f"Demo session ended: {session_summary['session_id']}")
+    
+    return {
+        "success": True,
+        **session_summary
+    }
+
+async def clear_all_issues():
+    """모든 활성 문제 해제"""
+    global active_issues
+    
+    cleared_issues = []
+    for issue_id, issue in active_issues.items():
+        cleared_issues.append({
+            "id": issue_id,
+            "type": issue["type"],
+            "description": f"{issue['type']} affecting {issue.get('station_id', 'system')}"
+        })
+    
+    active_issues.clear()
+    demo_session["current_issues"].clear()
+    
+    return {
+        "success": True,
+        "cleared_issues": cleared_issues,
+        "timestamp": datetime.now().isoformat()
+    }
+
+async def reset_simulation_state(request_data: dict):
+    """시뮬레이션 상태 리셋"""
+    preserve_data = request_data.get('preserve_data', True)
+    
+    # 성능 히스토리 리셋
+    demo_session["performance_history"].clear()
+    
+    # 카운터 리셋
+    if request_data.get('reset_counters', True):
+        demo_session["total_processed"] = 0
+    
+    return {
+        "success": True,
+        "preserved_records": demo_session["total_processed"] if preserve_data else 0,
+        "cache_cleared": True,
+        "counters_reset": True,
+        "timestamp": datetime.now().isoformat()
+    }
+
+async def schedule_auto_recovery(issue_id: str, issue_config: dict):
+    """자동 복구 스케줄링"""
+    recovery_delay = issue_config.get('duration_seconds', 60)
+    
+    # 지정된 시간 후 문제 해제
+    await asyncio.sleep(recovery_delay)
+    
+    if issue_id in active_issues:
+        del active_issues[issue_id]
+        if issue_id in demo_session["current_issues"]:
+            demo_session["current_issues"].remove(issue_id)
+        
+        logger.info(f"Auto-recovered issue: {issue_id}")
+
+def calculate_current_simulation_time():
+    """현재 시뮬레이션 시간 계산"""
+    if not demo_session["active"] or not demo_session["start_time"]:
+        return demo_session.get("simulation_start_time", "2025-07-01T00:00:00")
+    
+    # 실제 경과 시간 (분)
+    elapsed_real = (datetime.now() - demo_session["start_time"]).total_seconds() / 60
+    
+    # 시뮬레이션 시작 시간에 경과 시간 추가
+    sim_start = datetime.fromisoformat(demo_session["simulation_start_time"])
+    current_sim = sim_start + timedelta(minutes=elapsed_real)
+    
+    return current_sim.isoformat()
+
+def calculate_elapsed_real_minutes():
+    """실제 경과 시간 (분)"""
+    if not demo_session["active"] or not demo_session["start_time"]:
+        return 0
+    
+    return (datetime.now() - demo_session["start_time"]).total_seconds() / 60
+
+def get_current_rmse():
+    """현재 RMSE 값 (시뮬레이션)"""
+    base_rmse = 18.5  # 기본 RMSE
+    
+    # 활성 문제들의 영향
+    for issue in active_issues.values():
+        if issue["type"] == "extreme_weather":
+            base_rmse *= 1.8  # 극값 상황에서 RMSE 증가
+        elif issue["type"] == "sensor_malfunction":
+            base_rmse *= 1.3  # 센서 오류시 증가
+        elif issue["type"] == "data_corruption":
+            base_rmse *= 1.5  # 데이터 손상시 증가
+    
+    # 랜덤 변동
+    variation = np.random.normal(0, 2)
+    return round(max(10, base_rmse + variation), 1)
+
+def calculate_final_accuracy():
+    """최종 정확도 계산 (시뮬레이션)"""
+    base_accuracy = 89.2
+    
+    # 문제 상황들의 영향
+    for issue in active_issues.values():
+        if issue["type"] == "extreme_weather":
+            base_accuracy -= 15
+        elif issue["type"] == "sensor_malfunction":
+            base_accuracy -= 8
+        elif issue["type"] == "data_corruption":
+            base_accuracy -= 12
+    
+    return round(max(50, base_accuracy), 1)
+
+# ============================================================================
+# 간단한 데이터 처리기 (모듈이 없는 경우 대체)
+# ============================================================================
+
+class SimpleDataProcessor:
+    """간단한 데이터 처리기"""
+    
+    async def process_data(self, raw_data):
+        """데이터 처리 시뮬레이션"""
+        return raw_data
+    
+    async def save_to_database(self, processed_data):
+        """데이터베이스 저장 시뮬레이션"""
+        return len(processed_data)
+
+async def process_batch_data(stations_data: List[Dict], simulation_time: str):
+    """배치 데이터 처리"""
+    processed_count = 0
+    
+    for data_point in stations_data:
+        # 기본 검증
+        required_fields = ['station_id', 'date', 'air_pres', 'wind_dir', 'wind_speed', 'air_temp', 'tide_level']
+        
+        if all(field in data_point for field in required_fields):
+            # 천문조 계산 및 잔차 추가 (시뮬레이션)
+            astronomical_tide = calculate_astronomical_tide(
+                data_point['station_id'], 
+                data_point['date']
+            )
+            data_point['astronomical_tide'] = astronomical_tide
+            data_point['residual'] = data_point['tide_level'] - astronomical_tide
+            
+            processed_count += 1
+    
+    return processed_count
+
+def calculate_astronomical_tide(station_id: str, timestamp: str):
+    """천문조 계산 (시뮬레이션)"""
+    from datetime import datetime
+    
+    dt = datetime.fromisoformat(timestamp.replace('Z', '+00:00') if timestamp.endswith('Z') else timestamp)
+    hours = dt.hour + dt.minute / 60
+    
+    # 간단한 조석 계산
+    M2_period = 12.42
+    tide = 300 + 200 * np.sin(2 * np.pi * hours / M2_period)
+    
+    return round(tide, 1)
+
+async def simulate_data_collection():
+    """데이터 수집 시뮬레이션"""
+    stations = demo_session["active_stations"] if demo_session["active"] else ["DT_0001", "DT_0002"]
+    
+    collected_data = []
+    for station_id in stations:
+        data_point = {
+            "station_id": station_id,
+            "observed_at": datetime.now().isoformat(),
+            "tide_level": 300 + np.random.normal(0, 50),
+            "air_temp": 25 + np.random.normal(0, 3),
+            "air_pres": 1013 + np.random.normal(0, 5),
+            "wind_speed": max(0, np.random.normal(3, 2)),
+            "wind_dir": np.random.uniform(0, 360)
+        }
+        collected_data.append(data_point)
+    
+    return collected_data
+
+async def simulate_prediction_update():
+    """예측 업데이트 시뮬레이션"""
+    stations = demo_session["active_stations"] if demo_session["active"] else ["DT_0001", "DT_0002"]
+    
+    return {
+        "updated_count": len(stations),
+        "stations": stations
+    }
+
+async def update_demo_predictions(speed_multiplier: int):
+    """시연용 예측 업데이트"""
+    stations = demo_session["active_stations"]
+    
+    # 성능 히스토리 업데이트
+    current_rmse = get_current_rmse()
+    demo_session["performance_history"].append({
+        "timestamp": datetime.now().isoformat(),
+        "rmse": current_rmse,
+        "accuracy": calculate_final_accuracy()
+    })
+    
+    return {
+        "updated_count": len(stations),
+        "stations": stations,
+        "current_rmse": current_rmse
+    }
+
+async def emergency_recovery():
+    """응급 복구"""
+    global active_issues
+    
+    # 모든 문제 해제
+    cleared_count = len(active_issues)
+    active_issues.clear()
+    demo_session["current_issues"].clear()
+    
+    return {
+        "success": True,
+        "action": "emergency_recovery",
+        "cleared_issues": cleared_count,
+        "timestamp": datetime.now().isoformat()
+    }

performance_api.py

@@ -0,0 +1,651 @@
+"""
+Real-time Performance Evaluation API
+실시간 예측 성능 평가 및 모니터링 API
+"""
+
+from fastapi import FastAPI, HTTPException, Header, Query
+from datetime import datetime, timedelta
+import numpy as np
+import pandas as pd
+from typing import Optional, List, Dict, Any
+import logging
+from config import INTERNAL_API_KEY
+
+logger = logging.getLogger(__name__)
+
+# 성능 데이터 저장소 (실제로는 데이터베이스 사용)
+performance_cache = {
+    "realtime_metrics": {},
+    "historical_data": [],
+    "station_performance": {},
+    "alert_thresholds": {
+        "rmse_warning": 30.0,
+        "rmse_critical": 50.0,
+        "accuracy_warning": 80.0,
+        "accuracy_critical": 70.0
+    }
+}
+
+def verify_internal_api_key(authorization: str = Header(None)):
+    """내부 API 키 검증"""
+    if authorization and authorization.startswith("Bearer "):
+        return authorization == f"Bearer {INTERNAL_API_KEY}"
+    return False
+
+def register_performance_routes(app: FastAPI):
+    """성능 평가 API 라우트 등록"""
+    
+    @app.get("/api/performance/realtime", tags=["Performance"])
+    async def get_realtime_performance(
+        station_id: Optional[str] = Query(None, description="특정 관측소 성능 (전체: None)"),
+        authorization: str = Header(None)
+    ):
+        """실시간 예측 성능 지표 조회"""
+        
+        # 내부 API는 인증 필요, 외부는 읽기 전용
+        is_internal = verify_internal_api_key(authorization)
+        
+        try:
+            current_time = datetime.now()
+            
+            if station_id:
+                # 특정 관측소 성능
+                station_metrics = await get_station_performance(station_id)
+                return {
+                    "timestamp": current_time.isoformat(),
+                    "station_id": station_id,
+                    **station_metrics,
+                    "data_source": "realtime"
+                }
+            else:
+                # 전체 시스템 성능
+                overall_metrics = await get_overall_performance()
+                
+                response_data = {
+                    "timestamp": current_time.isoformat(),
+                    "rmse": overall_metrics["rmse"],
+                    "mae": overall_metrics["mae"],
+                    "accuracy": overall_metrics["accuracy"],
+                    "prediction_count": overall_metrics["prediction_count"],
+                    "active_stations": overall_metrics["active_stations"],
+                    "data_quality_score": overall_metrics["data_quality_score"],
+                    "status": overall_metrics["status"]
+                }
+                
+                # 내부 요청시 추가 정보 제공
+                if is_internal:
+                    response_data.update({
+                        "detailed_metrics": overall_metrics.get("detailed_metrics", {}),
+                        "station_breakdown": overall_metrics.get("station_breakdown", {}),
+                        "recent_alerts": overall_metrics.get("recent_alerts", [])
+                    })
+                
+                return response_data
+                
+        except Exception as e:
+            logger.error(f"Realtime performance query failed: {str(e)}")
+            raise HTTPException(status_code=500, detail=str(e))
+    
+    @app.get("/api/performance/historical", tags=["Performance"])
+    async def get_historical_performance(
+        hours: int = Query(24, description="조회할 시간 범위 (시간)"),
+        station_id: Optional[str] = Query(None, description="특정 관측소"),
+        metric: str = Query("rmse", description="성능 지표 (rmse/mae/accuracy)"),
+        authorization: str = Header(None)
+    ):
+        """성능 히스토리 조회"""
+        
+        is_internal = verify_internal_api_key(authorization)
+        
+        try:
+            # 시간 범위 검증
+            if hours > 168:  # 최대 1주일
+                hours = 168
+            
+            end_time = datetime.now()
+            start_time = end_time - timedelta(hours=hours)
+            
+            historical_data = await get_performance_history(
+                start_time, end_time, station_id, metric
+            )
+            
+            # 통계 계산
+            if historical_data:
+                values = [item[metric] for item in historical_data if item.get(metric) is not None]
+                
+                if values:
+                    statistics = {
+                        "mean": round(np.mean(values), 2),
+                        "std": round(np.std(values), 2),
+                        "min": round(min(values), 2),
+                        "max": round(max(values), 2),
+                        "trend": calculate_trend(values)
+                    }
+                else:
+                    statistics = None
+            else:
+                statistics = None
+            
+            return {
+                "timestamp": end_time.isoformat(),
+                "query_range": {
+                    "start_time": start_time.isoformat(),
+                    "end_time": end_time.isoformat(),
+                    "hours": hours
+                },
+                "station_id": station_id,
+                "metric": metric,
+                "data_points": len(historical_data),
+                "data": historical_data[-100:] if not is_internal else historical_data,  # 외부는 최근 100개만
+                "statistics": statistics
+            }
+            
+        except Exception as e:
+            logger.error(f"Historical performance query failed: {str(e)}")
+            raise HTTPException(status_code=500, detail=str(e))
+    
+    @app.get("/api/performance/comparison", tags=["Performance"])
+    async def compare_station_performance(
+        station_ids: str = Query(..., description="비교할 관측소들 (쉼표 구분)"),
+        metric: str = Query("rmse", description="비교할 성능 지표"),
+        period: str = Query("24h", description="비교 기간 (1h/6h/24h/7d)"),
+        authorization: str = Header(None)
+    ):
+        """관측소별 성능 비교"""
+        
+        is_internal = verify_internal_api_key(authorization)
+        
+        try:
+            # 관측소 목록 파싱
+            stations = [s.strip() for s in station_ids.split(",")]
+            
+            if len(stations) > 10:  # 최대 10개 관측소
+                stations = stations[:10]
+            
+            # 기간 파싱
+            period_hours = {
+                "1h": 1, "6h": 6, "24h": 24, "7d": 168
+            }.get(period, 24)
+            
+            comparison_data = {}
+            
+            for station_id in stations:
+                station_metrics = await get_station_performance_summary(
+                    station_id, period_hours, metric
+                )
+                comparison_data[station_id] = station_metrics
+            
+            # 순위 계산
+            if metric in ["rmse", "mae"]:
+                # 낮을수록 좋음
+                sorted_stations = sorted(
+                    comparison_data.items(),
+                    key=lambda x: x[1].get("current_value", float('inf'))
+                )
+            else:  # accuracy 등
+                # 높을수록 좋음
+                sorted_stations = sorted(
+                    comparison_data.items(),
+                    key=lambda x: x[1].get("current_value", 0),
+                    reverse=True
+                )
+            
+            return {
+                "timestamp": datetime.now().isoformat(),
+                "metric": metric,
+                "period": period,
+                "stations_count": len(stations),
+                "comparison": comparison_data,
+                "ranking": [{"rank": i+1, "station_id": station, "value": data["current_value"]} 
+                           for i, (station, data) in enumerate(sorted_stations)],
+                "best_performer": sorted_stations[0][0] if sorted_stations else None,
+                "summary": {
+                    "best_value": sorted_stations[0][1]["current_value"] if sorted_stations else None,
+                    "worst_value": sorted_stations[-1][1]["current_value"] if sorted_stations else None,
+                    "average_value": round(np.mean([data["current_value"] for data in comparison_data.values()]), 2)
+                }
+            }
+            
+        except Exception as e:
+            logger.error(f"Station comparison failed: {str(e)}")
+            raise HTTPException(status_code=500, detail=str(e))
+    
+    @app.get("/api/performance/alerts", tags=["Performance"])
+    async def get_performance_alerts(
+        active_only: bool = Query(True, description="활성 알림만 조회"),
+        hours: int = Query(24, description="조회할 시간 범위"),
+        authorization: str = Header(None)
+    ):
+        """성능 알림 조회"""
+        
+        verify_internal_api_key(authorization)  # 내부 API만 접근 가능
+        
+        try:
+            alerts = await get_current_alerts(active_only, hours)
+            
+            # 알림 분류
+            critical_alerts = [a for a in alerts if a["severity"] == "critical"]
+            warning_alerts = [a for a in alerts if a["severity"] == "warning"]
+            
+            return {
+                "timestamp": datetime.now().isoformat(),
+                "query_range_hours": hours,
+                "active_only": active_only,
+                "total_alerts": len(alerts),
+                "critical_count": len(critical_alerts),
+                "warning_count": len(warning_alerts),
+                "alerts": alerts,
+                "summary": {
+                    "system_status": "critical" if critical_alerts else ("warning" if warning_alerts else "normal"),
+                    "requires_attention": len(critical_alerts) > 0,
+                    "most_recent": alerts[0] if alerts else None
+                }
+            }
+            
+        except Exception as e:
+            logger.error(f"Performance alerts query failed: {str(e)}")
+            raise HTTPException(status_code=500, detail=str(e))
+    
+    @app.post("/api/performance/update", tags=["Performance"])
+    async def update_performance_metrics(
+        request_data: Dict[str, Any],
+        authorization: str = Header(None)
+    ):
+        """성능 지표 업데이트 (내부 사용)"""
+        
+        verify_internal_api_key(authorization)  # 내부 API만 접근 가능
+        
+        try:
+            station_id = request_data.get("station_id")
+            predictions = request_data.get("predictions", [])
+            actual_values = request_data.get("actual_values", [])
+            timestamp = request_data.get("timestamp", datetime.now().isoformat())
+            
+            if not predictions or not actual_values:
+                raise HTTPException(status_code=400, detail="Predictions and actual values required")
+            
+            if len(predictions) != len(actual_values):
+                raise HTTPException(status_code=400, detail="Predictions and actual values must have same length")
+            
+            # 성능 지표 계산
+            metrics = calculate_performance_metrics(predictions, actual_values)
+            
+            # 성능 데이터 저장
+            performance_record = {
+                "station_id": station_id,
+                "timestamp": timestamp,
+                "predictions": predictions,
+                "actual_values": actual_values,
+                "metrics": metrics,
+                "data_points": len(predictions)
+            }
+            
+            await save_performance_record(performance_record)
+            
+            # 실시간 캐시 업데이트
+            performance_cache["realtime_metrics"][station_id] = metrics
+            performance_cache["historical_data"].append(performance_record)
+            
+            # 오래된 데이터 정리 (메모리 관리)
+            if len(performance_cache["historical_data"]) > 1000:
+                performance_cache["historical_data"] = performance_cache["historical_data"][-500:]
+            
+            # 알림 체크
+            alerts = check_performance_alerts(station_id, metrics)
+            
+            return {
+                "success": True,
+                "timestamp": datetime.now().isoformat(),
+                "station_id": station_id,
+                "metrics": metrics,
+                "data_points": len(predictions),
+                "alerts_triggered": len(alerts),
+                "alerts": alerts
+            }
+            
+        except Exception as e:
+            logger.error(f"Performance update failed: {str(e)}")
+            raise HTTPException(status_code=500, detail=str(e))
+
+# ============================================================================
+# 성능 계산 및 분석 함수들
+# ============================================================================
+
+async def get_overall_performance():
+    """전체 시스템 성능 조회"""
+    
+    # 시연 모드에서는 시뮬레이션 데이터 사용
+    from internal_api import demo_session, active_issues
+    
+    base_rmse = 18.5
+    base_mae = 14.2
+    base_accuracy = 89.2
+    
+    # 활성 문제들의 영향 계산
+    rmse_multiplier = 1.0
+    accuracy_penalty = 0
+    
+    for issue in active_issues.values():
+        if issue["type"] == "extreme_weather":
+            rmse_multiplier *= 1.8
+            accuracy_penalty += 15
+        elif issue["type"] == "sensor_malfunction":
+            rmse_multiplier *= 1.3
+            accuracy_penalty += 8
+        elif issue["type"] == "data_corruption":
+            rmse_multiplier *= 1.5
+            accuracy_penalty += 12
+        elif issue["type"] == "network_failure":
+            rmse_multiplier *= 1.2
+            accuracy_penalty += 5
+    
+    # 랜덤 변동 추가
+    rmse_variation = np.random.normal(0, 2)
+    accuracy_variation = np.random.normal(0, 3)
+    
+    current_rmse = max(10, base_rmse * rmse_multiplier + rmse_variation)
+    current_mae = max(8, base_mae * rmse_multiplier * 0.8 + rmse_variation * 0.7)
+    current_accuracy = max(50, min(98, base_accuracy - accuracy_penalty + accuracy_variation))
+    
+    # 데이터 품질 점수
+    data_quality = 95 - len(active_issues) * 10
+    
+    # 상태 결정
+    if current_rmse > 40 or current_accuracy < 75:
+        status = "critical"
+    elif current_rmse > 25 or current_accuracy < 85:
+        status = "warning"
+    else:
+        status = "good"
+    
+    return {
+        "rmse": round(current_rmse, 1),
+        "mae": round(current_mae, 1),
+        "accuracy": round(current_accuracy, 1),
+        "prediction_count": demo_session.get("total_processed", 0),
+        "active_stations": len(demo_session.get("active_stations", [])),
+        "data_quality_score": round(data_quality, 1),
+        "status": status,
+        "detailed_metrics": {
+            "rmse_trend": "increasing" if len(active_issues) > 0 else "stable",
+            "prediction_latency_ms": np.random.randint(50, 200),
+            "data_freshness_minutes": np.random.randint(1, 10)
+        },
+        "station_breakdown": await get_all_stations_summary(),
+        "recent_alerts": await get_recent_alerts_summary()
+    }
+
+async def get_station_performance(station_id: str):
+    """특정 관측소 성능 조회"""
+    
+    # 기본 성능 + 관측소별 변동
+    station_seed = hash(station_id) % 1000
+    np.random.seed(station_seed)
+    
+    base_rmse = 18.5 + np.random.normal(0, 3)
+    base_mae = 14.2 + np.random.normal(0, 2)
+    base_accuracy = 89.2 + np.random.normal(0, 5)
+    
+    # 활성 문제 영향
+    from internal_api import active_issues
+    
+    for issue in active_issues.values():
+        if issue.get("station_id") == station_id or not issue.get("station_id"):
+            if issue["type"] == "sensor_malfunction" and issue.get("station_id") == station_id:
+                base_rmse *= 2.0
+                base_accuracy -= 25
+            elif issue["type"] == "extreme_weather":
+                base_rmse *= 1.6
+                base_accuracy -= 12
+    
+    return {
+        "rmse": round(max(10, base_rmse), 1),
+        "mae": round(max(8, base_mae), 1),
+        "accuracy": round(max(50, min(98, base_accuracy)), 1),
+        "data_points": np.random.randint(50, 200),
+        "last_prediction": (datetime.now() - timedelta(minutes=np.random.randint(1, 15))).isoformat(),
+        "status": "active" if station_id in demo_session.get("active_stations", []) else "inactive"
+    }
+
+async def get_performance_history(start_time, end_time, station_id, metric):
+    """성능 히스토리 생성 (시뮬레이션)"""
+    
+    data_points = []
+    current_time = start_time
+    
+    # 1시간 간격으로 데이터 생성
+    while current_time <= end_time:
+        
+        # 시간대별 기본값
+        hour = current_time.hour
+        base_value = {
+            "rmse": 18.5 + 5 * np.sin(2 * np.pi * hour / 24),
+            "mae": 14.2 + 3 * np.sin(2 * np.pi * hour / 24),
+            "accuracy": 89.2 - 8 * np.sin(2 * np.pi * hour / 24)
+        }
+        
+        # 랜덤 변동
+        variation = np.random.normal(0, 2)
+        value = base_value[metric] + variation
+        
+        # 관측소별 조정
+        if station_id:
+            station_offset = hash(station_id) % 10 - 5
+            value += station_offset
+        
+        data_points.append({
+            "timestamp": current_time.isoformat(),
+            "station_id": station_id,
+            metric: round(value, 1),
+            "data_points": np.random.randint(10, 50)
+        })
+        
+        current_time += timedelta(hours=1)
+    
+    return data_points
+
+async def get_station_performance_summary(station_id, period_hours, metric):
+    """관측소 성능 요약"""
+    
+    # 현재 성능
+    current_perf = await get_station_performance(station_id)
+    current_value = current_perf[metric]
+    
+    # 기간별 평균 (시뮬레이션)
+    period_variation = np.random.normal(0, 5)
+    period_average = current_value + period_variation
+    
+    # 트렌드 계산
+    trend_change = np.random.uniform(-10, 10)
+    trend = "improving" if trend_change < -2 else ("degrading" if trend_change > 2 else "stable")
+    
+    return {
+        "station_id": station_id,
+        "current_value": current_value,
+        "period_average": round(period_average, 1),
+        "trend": trend,
+        "trend_change": round(trend_change, 1),
+        "data_points": np.random.randint(20, 100),
+        "last_update": datetime.now().isoformat()
+    }
+
+def calculate_performance_metrics(predictions, actual_values):
+    """성능 지표 계산"""
+    
+    predictions = np.array(predictions)
+    actual_values = np.array(actual_values)
+    
+    # RMSE
+    rmse = np.sqrt(np.mean((predictions - actual_values) ** 2))
+    
+    # MAE
+    mae = np.mean(np.abs(predictions - actual_values))
+    
+    # 정확도 (95% 신뢰구간 내 예측 비율)
+    errors = np.abs(predictions - actual_values)
+    threshold = np.percentile(errors, 95)
+    accuracy = np.mean(errors <= threshold) * 100
+    
+    # 추가 지표
+    mape = np.mean(np.abs((actual_values - predictions) / actual_values)) * 100
+    r2 = 1 - (np.sum((actual_values - predictions) ** 2) / np.sum((actual_values - np.mean(actual_values)) ** 2))
+    
+    return {
+        "rmse": round(rmse, 2),
+        "mae": round(mae, 2),
+        "accuracy": round(accuracy, 1),
+        "mape": round(mape, 2),
+        "r2_score": round(r2, 3),
+        "data_points": len(predictions)
+    }
+
+def calculate_trend(values):
+    """트렌드 계산"""
+    if len(values) < 3:
+        return "insufficient_data"
+    
+    # 선형 회귀로 기울기 계산
+    x = np.arange(len(values))
+    slope = np.polyfit(x, values, 1)[0]
+    
+    if slope > 0.5:
+        return "increasing"
+    elif slope < -0.5:
+        return "decreasing"
+    else:
+        return "stable"
+
+def check_performance_alerts(station_id, metrics):
+    """성능 알림 체크"""
+    
+    alerts = []
+    thresholds = performance_cache["alert_thresholds"]
+    
+    # RMSE 체크
+    rmse = metrics["rmse"]
+    if rmse > thresholds["rmse_critical"]:
+        alerts.append({
+            "type": "rmse_critical",
+            "severity": "critical",
+            "message": f"Critical RMSE level: {rmse} cm",
+            "station_id": station_id,
+            "threshold": thresholds["rmse_critical"],
+            "current_value": rmse,
+            "timestamp": datetime.now().isoformat()
+        })
+    elif rmse > thresholds["rmse_warning"]:
+        alerts.append({
+            "type": "rmse_warning",
+            "severity": "warning",
+            "message": f"High RMSE level: {rmse} cm",
+            "station_id": station_id,
+            "threshold": thresholds["rmse_warning"],
+            "current_value": rmse,
+            "timestamp": datetime.now().isoformat()
+        })
+    
+    # 정확도 체크
+    accuracy = metrics["accuracy"]
+    if accuracy < thresholds["accuracy_critical"]:
+        alerts.append({
+            "type": "accuracy_critical",
+            "severity": "critical",
+            "message": f"Critical accuracy drop: {accuracy}%",
+            "station_id": station_id,
+            "threshold": thresholds["accuracy_critical"],
+            "current_value": accuracy,
+            "timestamp": datetime.now().isoformat()
+        })
+    elif accuracy < thresholds["accuracy_warning"]:
+        alerts.append({
+            "type": "accuracy_warning",
+            "severity": "warning",
+            "message": f"Low accuracy: {accuracy}%",
+            "station_id": station_id,
+            "threshold": thresholds["accuracy_warning"],
+            "current_value": accuracy,
+            "timestamp": datetime.now().isoformat()
+        })
+    
+    return alerts
+
+async def get_current_alerts(active_only, hours):
+    """현재 알림 조회 (시뮬레이션)"""
+    
+    from internal_api import active_issues, demo_session
+    
+    alerts = []
+    
+    # 활성 문제들을 알림으로 변환
+    for issue_id, issue in active_issues.items():
+        alerts.append({
+            "id": issue_id,
+            "type": f"{issue['type']}_alert",
+            "severity": "critical" if issue["type"] in ["extreme_weather", "sensor_malfunction"] else "warning",
+            "message": f"{issue['type'].replace('_', ' ').title()} detected",
+            "station_id": issue.get("station_id"),
+            "timestamp": issue["start_time"].isoformat(),
+            "duration_minutes": (datetime.now() - issue["start_time"]).total_seconds() / 60,
+            "active": True
+        })
+    
+    # 추가 성능 알림 시뮬레이션
+    if demo_session.get("active"):
+        current_perf = await get_overall_performance()
+        
+        if current_perf["rmse"] > 30:
+            alerts.append({
+                "id": "perf_rmse_high",
+                "type": "performance_degradation",
+                "severity": "warning",
+                "message": f"High system RMSE: {current_perf['rmse']} cm",
+                "timestamp": (datetime.now() - timedelta(minutes=5)).isoformat(),
+                "duration_minutes": 5,
+                "active": True
+            })
+    
+    # 정렬 (최신순)
+    alerts.sort(key=lambda x: x["timestamp"], reverse=True)
+    
+    return alerts
+
+async def get_all_stations_summary():
+    """모든 관측소 성능 요약"""
+    
+    from internal_api import demo_session
+    stations = demo_session.get("active_stations", ["DT_0001", "DT_0002"])
+    
+    summary = {}
+    for station_id in stations:
+        perf = await get_station_performance(station_id)
+        summary[station_id] = {
+            "rmse": perf["rmse"],
+            "accuracy": perf["accuracy"],
+            "status": perf["status"]
+        }
+    
+    return summary
+
+async def get_recent_alerts_summary():
+    """최근 알림 요약"""
+    
+    alerts = await get_current_alerts(True, 1)  # 최근 1시간
+    
+    return {
+        "total_count": len(alerts),
+        "critical_count": sum(1 for a in alerts if a["severity"] == "critical"),
+        "most_recent": alerts[0] if alerts else None
+    }
+
+async def save_performance_record(performance_record):
+    """성능 기록 저장 (실제로는 데이터베이스 사용)"""
+    
+    # 여기서는 메모리에만 저장 (시뮬레이션)
+    performance_cache["historical_data"].append(performance_record)
+    
+    # 실제 구현에서는 Supabase나 다른 DB에 저장
+    # await supabase.table("performance_metrics").insert(performance_record)
+    
+    pass
+
+logger.info("Performance API module loaded successfully")

test.py

@@ -0,0 +1,37 @@
+# app_simple.py - Gradio만 사용
+import gradio as gr
+import warnings
+warnings.filterwarnings('ignore')
+
+from prediction import single_prediction
+from chatbot import process_chatbot_query_with_llm
+from ui import create_ui
+from api_utils import (
+    api_get_tide_level,
+    api_get_tide_series,
+    api_get_extremes_info,
+    api_check_tide_alert,
+    api_compare_stations,
+    api_health_check
+)
+
+# API 핸들러
+api_handlers = {
+    "health": api_health_check,
+    "tide_level": api_get_tide_level,
+    "tide_series": api_get_tide_series,
+    "extremes": api_get_extremes_info,
+    "alert": api_check_tide_alert,
+    "compare": api_compare_stations
+}
+
+# Gradio UI만 실행
+demo = create_ui(
+    prediction_handler=single_prediction,
+    chatbot_handler=process_chatbot_query_with_llm,
+    api_handlers=api_handlers
+)
+
+# FastAPI 없이 Gradio만 실행
+if __name__ == "__main__":
+    demo.launch()