Delete internal_api.py

internal_api.py

@@ -1,754 +0,0 @@
-"""
-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()
-    }