Update app.py

app.py

@@ -646,6 +646,257 @@ def api_get_extremes(station_id, hours=24):
         "count": len(extremes),
         "extremes": extremes
     }
+def api_get_historical_tide(station_id, date_str, hours=24):
+    """과거 특정 날짜의 조위 데이터 조회"""
+    supabase = get_supabase_client()
+    if not supabase:
+        return {"error": "Database connection failed"}
+    
+    try:
+        # 날짜 파싱 (YYYY-MM-DD 형식)
+        start_date = datetime.strptime(date_str, "%Y-%m-%d")
+        end_date = start_date + timedelta(hours=hours)
+        
+        # 과거 예측 데이터 조회
+        result = supabase.table('tide_predictions')\
+            .select('predicted_at, final_tide_level, harmonic_level, predicted_residual')\
+            .eq('station_id', station_id)\
+            .gte('predicted_at', start_date.isoformat())\
+            .lte('predicted_at', end_date.isoformat())\
+            .order('predicted_at')\
+            .execute()
+        
+        if result.data:
+            # 통계 계산
+            levels = [d['final_tide_level'] for d in result.data]
+            
+            return {
+                "station_id": station_id,
+                "date": date_str,
+                "hours": hours,
+                "count": len(result.data),
+                "statistics": {
+                    "max": max(levels),
+                    "min": min(levels),
+                    "avg": sum(levels) / len(levels)
+                },
+                "data": result.data[:100]  # 최대 100개만 반환
+            }
+        
+        # 예측 데이터가 없으면 관측 데이터 확인
+        result = supabase.table('tide_observations')\
+            .select('observed_at, residual, air_pres, wind_speed, air_temp')\
+            .eq('station_id', station_id)\
+            .gte('observed_at', start_date.isoformat())\
+            .lte('observed_at', end_date.isoformat())\
+            .order('observed_at')\
+            .execute()
+        
+        if result.data:
+            return {
+                "station_id": station_id,
+                "date": date_str,
+                "type": "observation",  # 관측 데이터임을 표시
+                "count": len(result.data),
+                "data": result.data[:100]
+            }
+        
+        return {"error": "No historical data found for this date"}
+        
+    except Exception as e:
+        return {"error": f"Date parsing error: {str(e)}"}
+
+def api_get_historical_extremes(station_id, date_str):
+    """과거 특정 날짜의 만조/간조 정보"""
+    supabase = get_supabase_client()
+    if not supabase:
+        return {"error": "Database connection failed"}
+    
+    try:
+        # 하루 전체 데이터
+        start_date = datetime.strptime(date_str, "%Y-%m-%d")
+        end_date = start_date + timedelta(days=1)
+        
+        result = supabase.table('tide_predictions')\
+            .select('predicted_at, final_tide_level')\
+            .eq('station_id', station_id)\
+            .gte('predicted_at', start_date.isoformat())\
+            .lt('predicted_at', end_date.isoformat())\
+            .order('predicted_at')\
+            .execute()
+        
+        if not result.data or len(result.data) < 3:
+            return {"error": "Insufficient data for this date"}
+        
+        # 극값 찾기
+        extremes = []
+        data = result.data
+        
+        for i in range(1, len(data) - 1):
+            prev_level = data[i-1]['final_tide_level']
+            curr_level = data[i]['final_tide_level']
+            next_level = data[i+1]['final_tide_level']
+            
+            if curr_level > prev_level and curr_level > next_level:
+                extremes.append({
+                    'type': 'high',
+                    'time': data[i]['predicted_at'],
+                    'level': curr_level
+                })
+            elif curr_level < prev_level and curr_level < next_level:
+                extremes.append({
+                    'type': 'low',
+                    'time': data[i]['predicted_at'],
+                    'level': curr_level
+                })
+        
+        # 최고/최저 찾기
+        all_levels = [d['final_tide_level'] for d in data]
+        daily_max = max(all_levels)
+        daily_min = min(all_levels)
+        
+        return {
+            "station_id": station_id,
+            "date": date_str,
+            "daily_max": daily_max,
+            "daily_min": daily_min,
+            "daily_range": daily_max - daily_min,
+            "extremes": extremes,
+            "high_tide_count": len([e for e in extremes if e['type'] == 'high']),
+            "low_tide_count": len([e for e in extremes if e['type'] == 'low'])
+        }
+        
+    except Exception as e:
+        return {"error": f"Error: {str(e)}"}
+
+def api_compare_dates(station_id, date1, date2):
+    """두 날짜의 조위 패턴 비교"""
+    supabase = get_supabase_client()
+    if not supabase:
+        return {"error": "Database connection failed"}
+    
+    try:
+        results = {}
+        
+        for date_str in [date1, date2]:
+            start_date = datetime.strptime(date_str, "%Y-%m-%d")
+            end_date = start_date + timedelta(days=1)
+            
+            result = supabase.table('tide_predictions')\
+                .select('predicted_at, final_tide_level')\
+                .eq('station_id', station_id)\
+                .gte('predicted_at', start_date.isoformat())\
+                .lt('predicted_at', end_date.isoformat())\
+                .order('predicted_at')\
+                .execute()
+            
+            if result.data:
+                levels = [d['final_tide_level'] for d in result.data]
+                results[date_str] = {
+                    "max": max(levels),
+                    "min": min(levels),
+                    "avg": sum(levels) / len(levels),
+                    "range": max(levels) - min(levels)
+                }
+        
+        if len(results) == 2:
+            # 차이 계산
+            diff = {
+                "max_diff": results[date1]["max"] - results[date2]["max"],
+                "min_diff": results[date1]["min"] - results[date2]["min"],
+                "avg_diff": results[date1]["avg"] - results[date2]["avg"],
+                "range_diff": results[date1]["range"] - results[date2]["range"]
+            }
+            
+            return {
+                "station_id": station_id,
+                "date1": {**{"date": date1}, **results[date1]},
+                "date2": {**{"date": date2}, **results[date2]},
+                "difference": diff
+            }
+        
+        return {"error": "Data not available for both dates"}
+        
+    except Exception as e:
+        return {"error": f"Error: {str(e)}"}
+
+def api_get_monthly_summary(station_id, year, month):
+    """월간 조위 요약 통계"""
+    supabase = get_supabase_client()
+    if not supabase:
+        return {"error": "Database connection failed"}
+    
+    try:
+        # 월 시작/종료 날짜
+        start_date = datetime(year, month, 1)
+        if month == 12:
+            end_date = datetime(year + 1, 1, 1)
+        else:
+            end_date = datetime(year, month + 1, 1)
+        
+        result = supabase.table('tide_predictions')\
+            .select('predicted_at, final_tide_level')\
+            .eq('station_id', station_id)\
+            .gte('predicted_at', start_date.isoformat())\
+            .lt('predicted_at', end_date.isoformat())\
+            .execute()
+        
+        if not result.data:
+            return {"error": "No data for this month"}
+        
+        # 일별 통계 계산
+        daily_stats = {}
+        for item in result.data:
+            date = item['predicted_at'][:10]  # YYYY-MM-DD
+            if date not in daily_stats:
+                daily_stats[date] = []
+            daily_stats[date].append(item['final_tide_level'])
+        
+        # 월간 통계
+        all_levels = [d['final_tide_level'] for d in result.data]
+        monthly_max = max(all_levels)
+        monthly_min = min(all_levels)
+        
+        # 가장 높았던 날과 낮았던 날 찾기
+        highest_day = None
+        lowest_day = None
+        highest_value = 0
+        lowest_value = 9999
+        
+        for date, levels in daily_stats.items():
+            day_max = max(levels)
+            day_min = min(levels)
+            
+            if day_max > highest_value:
+                highest_value = day_max
+                highest_day = date
+            
+            if day_min < lowest_value:
+                lowest_value = day_min
+                lowest_day = date
+        
+        return {
+            "station_id": station_id,
+            "year": year,
+            "month": month,
+            "statistics": {
+                "monthly_max": monthly_max,
+                "monthly_min": monthly_min,
+                "monthly_avg": sum(all_levels) / len(all_levels),
+                "monthly_range": monthly_max - monthly_min,
+                "total_observations": len(result.data),
+                "days_with_data": len(daily_stats)
+            },
+            "extreme_days": {
+                "highest_tide_day": highest_day,
+                "highest_tide_value": highest_value,
+                "lowest_tide_day": lowest_day,
+                "lowest_tide_value": lowest_value
+            }
+        }
+        
+    except Exception as e:
+        return {"error": f"Error: {str(e)}"}
 
 # --- 5. Gradio 인터페이스 ---
 with gr.Blocks(title="통합 조위 예측 시스템", theme=gr.themes.Soft()) as demo:
@@ -787,6 +1038,120 @@ with gr.Blocks(title="통합 조위 예측 시스템", theme=gr.themes.Soft()) a
                         outputs=api_extreme_output,
                         api_name="extremes"
                     )
+        with gr.TabItem("📜 과거 데이터"):
+        gr.Markdown("""
+        ### 과거 조위 데이터 조회
+        특정 날짜의 조위 정보를 확인할 수 있습니다.
+        """)
+        
+            with gr.Row():
+                with gr.Column():
+                    hist_station = gr.Dropdown(
+                        choices=[(f"{STATION_NAMES[s]} ({s})", s) for s in STATIONS],
+                        label="관측소 선택",
+                        value=STATIONS[0]
+                    )
+                    hist_date = gr.Textbox(
+                        label="날짜 (YYYY-MM-DD)",
+                        value=datetime.now().strftime("%Y-%m-%d")
+                    )
+                    hist_hours = gr.Number(
+                        label="조회 시간 (시간)",
+                        value=24,
+                        minimum=1,
+                        maximum=168
+                    )
+                    
+                    hist_btn = gr.Button("조회", variant="primary")
+                    
+                with gr.Column():
+                    hist_output = gr.JSON(label="조회 결과")
+            
+            hist_btn.click(
+                fn=api_get_historical_tide,
+                inputs=[hist_station, hist_date, hist_hours],
+                outputs=hist_output,
+                api_name="historical_tide"
+            )
+            
+            # 과거 만조/간조
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("### 과거 만조/간조 정보")
+                    ext_station = gr.Dropdown(
+                        choices=[(f"{STATION_NAMES[s]} ({s})", s) for s in STATIONS],
+                        label="관측소",
+                        value=STATIONS[0]
+                    )
+                    ext_date = gr.Textbox(
+                        label="날짜 (YYYY-MM-DD)",
+                        value=(datetime.now() - timedelta(days=7)).strftime("%Y-%m-%d")
+                    )
+                    ext_btn = gr.Button("만조/간조 조회")
+                    ext_output = gr.JSON(label="만조/간조 정보")
+                    
+                with gr.Column():
+                    gr.Markdown("### 날짜 비교")
+                    comp_station = gr.Dropdown(
+                        choices=[(f"{STATION_NAMES[s]} ({s})", s) for s in STATIONS],
+                        label="관측소",
+                        value=STATIONS[0]
+                    )
+                    comp_date1 = gr.Textbox(
+                        label="날짜 1",
+                        value=datetime.now().strftime("%Y-%m-%d")
+                    )
+                    comp_date2 = gr.Textbox(
+                        label="날짜 2",
+                        value=(datetime.now() - timedelta(days=7)).strftime("%Y-%m-%d")
+                    )
+                    comp_btn = gr.Button("비교")
+                    comp_output = gr.JSON(label="비교 결과")
+            
+            ext_btn.click(
+                fn=api_get_historical_extremes,
+                inputs=[ext_station, ext_date],
+                outputs=ext_output,
+                api_name="historical_extremes"
+            )
+            
+            comp_btn.click(
+                fn=api_compare_dates,
+                inputs=[comp_station, comp_date1, comp_date2],
+                outputs=comp_output,
+                api_name="compare_dates"
+            )
+            
+            # 월간 요약
+            gr.Markdown("### 월간 요약 통계")
+            with gr.Row():
+                month_station = gr.Dropdown(
+                    choices=[(f"{STATION_NAMES[s]} ({s})", s) for s in STATIONS],
+                    label="관측소",
+                    value=STATIONS[0]
+                )
+                month_year = gr.Number(
+                    label="년도",
+                    value=datetime.now().year,
+                    precision=0
+                )
+                month_month = gr.Number(
+                    label="월",
+                    value=datetime.now().month,
+                    minimum=1,
+                    maximum=12,
+                    precision=0
+                )
+                month_btn = gr.Button("월간 통계 조회")
+            
+            month_output = gr.JSON(label="월간 통계")
+            
+            month_btn.click(
+                fn=api_get_monthly_summary,
+                inputs=[month_station, month_year, month_month],
+                outputs=month_output,
+                api_name="monthly_summary"
+            )
 
 if __name__ == "__main__":
     demo.launch()