Spaces:
Sleeping
Sleeping
| """ | |
| Hydro-Agro Dashboard v3.7 (Fixed Buttons & Text) | |
| FIXED: Aggregation now properly applies before analysis | |
| """ | |
| import gradio as gr | |
| import pandas as pd | |
| import numpy as np | |
| import os | |
| from datetime import datetime | |
| import plotly.graph_objects as go | |
| from plotly.subplots import make_subplots | |
| # Import components | |
| from components.data_loader import DataLoader | |
| from components.aggregation import AggregationEngine | |
| from components.window_selection import WindowSelector | |
| from components.map_view import create_map_panel | |
| # Import analysis modules | |
| from analysis.recharge import RechargeAnalyzer | |
| from analysis.qc_diagnostics import QCDiagnostics | |
| from analysis.agri_water_stress import AgriWaterStress | |
| from analysis.hydroclimate_intelligence import HydroclimateIntelligence | |
| # Import utilities | |
| from utils.preprocessing import DataPreprocessor | |
| from utils.export_handler import ExportHandler | |
| # Initialize components | |
| data_loader = DataLoader() | |
| preprocessor = DataPreprocessor() | |
| aggregator = AggregationEngine() | |
| window_selector = WindowSelector() | |
| export_handler = ExportHandler() | |
| # Initialize analysis engines | |
| recharge_analyzer = RechargeAnalyzer() | |
| qc_diagnostics = QCDiagnostics() | |
| agri_stress = AgriWaterStress() | |
| hydroclimate = HydroclimateIntelligence() | |
| # Global state | |
| class DashboardState: | |
| def __init__(self): | |
| self.df = None | |
| self.df_filtered = None | |
| self.df_aggregated = None | |
| self.current_analysis = None | |
| state = DashboardState() | |
| def load_and_initialize(file_obj, use_sample): | |
| """ | |
| Combined function: Loads data AND automatically runs the default analysis. | |
| """ | |
| try: | |
| # 1. Load Data | |
| if use_sample or file_obj is None: | |
| df = data_loader.load_sample_data() | |
| source_msg = "Sample Data (2025)" | |
| else: | |
| df = data_loader.load_uploaded_file(file_obj.name) | |
| source_msg = "Custom File Uploaded" | |
| # 2. Preprocess | |
| df = preprocessor.clean_data(df) | |
| df = preprocessor.add_derived_columns(df) | |
| # Update State | |
| state.df = df | |
| state.df_filtered = df | |
| state.df_aggregated = df # Initial aggregation is raw data | |
| # AUTO-DETECT DATE RANGE | |
| date_start = df['timestamp'].min().strftime('%Y-%m-%d') | |
| date_end = df['timestamp'].max().strftime('%Y-%m-%d') | |
| # 3. Auto-Run Hydroclimate Analysis with Daily aggregation | |
| results_text, fig, metrics_df, insights_text = run_analysis("Hydroclimate Overview", "Daily") | |
| # 4. Generate Detailed Status Info | |
| status_info = f""" | |
| ### ✅ {source_msg} | |
| | Metric | Details | | |
| | :--- | :--- | | |
| | **Records** | {len(df):,} | | |
| | **Range** | {df['timestamp'].min().date()} — {df['timestamp'].max().date()} | | |
| | **Sensors** | {len(df.columns)-1} Active | | |
| """ | |
| # Return all updates INCLUDING DATE UPDATES | |
| return ( | |
| status_info, # Update Status Panel | |
| fig, # Main plot | |
| gr.update(visible=True), # Show Filter group | |
| gr.update(visible=True), # Show Analysis group | |
| results_text, # Results text | |
| metrics_df, # Metrics table | |
| gr.update(visible=True), # Show metrics table visibility | |
| insights_text, # Policy insights text | |
| gr.update(value=date_start), # UPDATE START DATE | |
| gr.update(value=date_end) # UPDATE END DATE | |
| ) | |
| except Exception as e: | |
| error_msg = f"❌ Error: {str(e)}" | |
| return error_msg, None, gr.update(visible=False), gr.update(visible=False), "", None, gr.update(visible=False), "", gr.update(), gr.update() | |
| def create_visualization(df): | |
| """ | |
| Basic visualization for overview | |
| """ | |
| if df is None: return None | |
| fig = make_subplots( | |
| rows=3, cols=1, | |
| subplot_titles=('Soil Moisture', 'Temperature', 'Precipitation'), | |
| shared_xaxes=True, | |
| vertical_spacing=0.08, | |
| row_heights=[0.35, 0.35, 0.3] | |
| ) | |
| # Downsample if needed | |
| if len(df) > 5000: | |
| step = len(df) // 5000 | |
| df_lines = df.iloc[::step] | |
| else: | |
| df_lines = df | |
| # Soil Moisture | |
| if 'SM_5cm' in df.columns: | |
| fig.add_trace(go.Scatter(x=df_lines['timestamp'], y=df_lines['SM_5cm'], | |
| name='5cm', line=dict(color='green', width=1.5)), row=1, col=1) | |
| if 'SM_50cm' in df.columns: | |
| fig.add_trace(go.Scatter(x=df_lines['timestamp'], y=df_lines['SM_50cm'], | |
| name='50cm', line=dict(color='brown', width=1.5)), row=1, col=1) | |
| # Temperature | |
| if 'Temp_5cm' in df.columns: | |
| fig.add_trace(go.Scatter(x=df_lines['timestamp'], y=df_lines['Temp_5cm'], | |
| name='Temp', line=dict(color='red', width=1.5)), row=2, col=1) | |
| # Precipitation | |
| if 'Precipitation' in df.columns: | |
| if len(df) > 1000: | |
| precip = df.set_index('timestamp')['Precipitation'].resample('D').sum().reset_index() | |
| fig.add_trace(go.Bar(x=precip['timestamp'], y=precip['Precipitation'], | |
| name='Daily Precip', marker_color='blue', opacity=0.7), row=3, col=1) | |
| else: | |
| fig.add_trace(go.Bar(x=df['timestamp'], y=df['Precipitation'], | |
| name='Precip', marker_color='blue', opacity=0.7), row=3, col=1) | |
| fig.update_layout( | |
| margin=dict(l=20, r=20, t=40, b=20), | |
| height=500, | |
| template='plotly_white', | |
| hovermode='x unified', | |
| showlegend=True | |
| ) | |
| return fig | |
| def apply_filters(aggregation, start_date, end_date): | |
| """Update filters and refresh plot""" | |
| if state.df is None: return "⚠️ Load data first", None | |
| try: | |
| start = pd.to_datetime(start_date) | |
| end = pd.to_datetime(end_date) | |
| filtered = window_selector.apply_date_filter(state.df, (start, end)) | |
| aggregated = aggregator.aggregate(filtered, aggregation) | |
| state.df_filtered = filtered | |
| state.df_aggregated = aggregated | |
| fig = create_visualization(aggregated) | |
| info = f""" | |
| ### ✅ View Updated | |
| * **Resolution:** {aggregation} | |
| * **Records:** {len(aggregated):,} | |
| * **Range:** {start.date()} — {end.date()} | |
| """ | |
| return info, fig | |
| except Exception as e: | |
| return f"❌ Error: {str(e)}", None | |
| def run_analysis(analysis_type, aggregation_level): | |
| """ | |
| Run analysis module with proper aggregation applied | |
| FIXED: Now applies aggregation BEFORE running analysis | |
| """ | |
| if state.df_filtered is None: | |
| return "⚠️ Load data first", None, None, "" | |
| # CRITICAL FIX: Apply current aggregation setting before analysis | |
| df = aggregator.aggregate(state.df_filtered, aggregation_level) | |
| metrics_data = [] | |
| insights_text = "" | |
| try: | |
| if analysis_type == "Recharge Analysis": | |
| results = recharge_analyzer.analyze(df) | |
| fig = recharge_analyzer.create_recharge_plot(df) | |
| metrics_df = recharge_analyzer.get_metrics_dataframe(df) | |
| text = f"### Recharge Analysis ({aggregation_level})\nSee visualization and metrics." | |
| if hasattr(recharge_analyzer, 'get_policy_insights'): | |
| insights_text = recharge_analyzer.get_policy_insights(df) | |
| elif analysis_type == "Agricultural Stress": | |
| results = agri_stress.analyze(df) | |
| fig = agri_stress.create_stress_plot(df) | |
| metrics_df = agri_stress.get_metrics_dataframe(df) | |
| text = f"### Agricultural Stress Analysis ({aggregation_level})\nSee visualization and metrics." | |
| if hasattr(agri_stress, 'get_policy_insights'): | |
| insights_text = agri_stress.get_policy_insights(df) | |
| elif analysis_type == "Sensor QC": | |
| results = qc_diagnostics.analyze(df) | |
| fig = qc_diagnostics.create_diagnostic_plot(df) | |
| metrics_df = qc_diagnostics.get_metrics_dataframe(df) | |
| text = f"### Sensor QC Analysis ({aggregation_level})\nSee visualization and metrics." | |
| if hasattr(qc_diagnostics, 'get_policy_insights'): | |
| insights_text = qc_diagnostics.get_policy_insights(df) | |
| else: # Hydroclimate Overview | |
| results = hydroclimate.get_basic_stats(df) | |
| # Use enhanced plot if available | |
| if hasattr(hydroclimate, 'create_enhanced_plot'): | |
| fig = hydroclimate.create_enhanced_plot(df) | |
| else: | |
| fig = create_visualization(df) | |
| # Get enhanced metrics | |
| if hasattr(hydroclimate, 'get_metrics_dataframe'): | |
| metrics_df = hydroclimate.get_metrics_dataframe(df) | |
| else: | |
| # Fallback metrics | |
| if 'Temp_5cm' in df: | |
| metrics_data.append(["Avg Temp", f"{df['Temp_5cm'].mean():.1f}", "°C"]) | |
| metrics_data.append(["Max Temp", f"{df['Temp_5cm'].max():.1f}", "°C"]) | |
| if 'Precipitation' in df: | |
| metrics_data.append(["Total Rain", f"{df['Precipitation'].sum():.1f}", "mm"]) | |
| if 'SM_5cm' in df: | |
| metrics_data.append(["Avg Moisture", f"{df['SM_5cm'].mean():.1f}", "%"]) | |
| metrics_df = pd.DataFrame(metrics_data, columns=["Metric", "Value", "Unit"]) | |
| text = f"### Hydroclimate Overview ({aggregation_level})\nSee visualization and metrics." | |
| # Get policy insights | |
| if hasattr(hydroclimate, 'get_policy_insights'): | |
| insights_text = hydroclimate.get_policy_insights(df) | |
| state.current_analysis = {'type': analysis_type, 'results': results} | |
| return text, fig, metrics_df, insights_text | |
| except Exception as e: | |
| import traceback | |
| return f"❌ Analysis Error: {str(e)}", None, None, "" | |
| def export_data(fmt): | |
| """Export handler""" | |
| if state.df_aggregated is None: | |
| return "⚠️ No data", None | |
| try: | |
| atype = state.current_analysis['type'] if state.current_analysis else 'general' | |
| if fmt == "CSV": | |
| path = export_handler.export_csv(state.df_aggregated, atype) | |
| elif fmt == "Excel": | |
| path = export_handler.export_excel(state.df_aggregated, atype) | |
| else: | |
| path = export_handler.generate_report(state.df_aggregated, atype) | |
| return f"✅ Saved: {os.path.basename(path)}", path | |
| except Exception as e: | |
| return f"❌ Error: {e}", None | |
| # --- UI Layout --- | |
| def create_app(): | |
| # Create Map HTML | |
| initial_map_html = create_map_panel(None) | |
| # FIXED CSS - Better button visibility | |
| css = """ | |
| /* Mobile responsiveness */ | |
| @media (max-width: 768px) { | |
| .gr-button { | |
| min-height: 44px !important; | |
| font-size: 14px !important; | |
| } | |
| .map-container { | |
| height: 200px !important; | |
| } | |
| } | |
| /* Main Containers */ | |
| .map-container { | |
| border-radius: 12px; | |
| overflow: hidden; | |
| border: 1px solid #e5e7eb; | |
| box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1); | |
| } | |
| .load-container { | |
| border-radius: 12px; | |
| border: 1px solid #e5e7eb; | |
| padding: 20px; | |
| background: #f9fafb; | |
| height: 100%; | |
| box-shadow: 0 1px 3px rgba(0,0,0,0.1); | |
| } | |
| /* Policy Insights Panel */ | |
| .insights-panel { | |
| background: linear-gradient(135deg, #f0f9ff 0%, #e0f2fe 100%); | |
| border-left: 4px solid #0284c7; | |
| padding: 15px; | |
| border-radius: 8px; | |
| color: #0f172a !important; /* FIX: readable text on mobile */ | |
| } | |
| /* FIX: Radio Buttons with Better Visibility */ | |
| .module-selector fieldset { | |
| gap: 10px; | |
| } | |
| .module-selector label { | |
| padding: 10px 14px !important; | |
| background: white !important; | |
| border: 2px solid #e5e7eb !important; | |
| border-radius: 8px !important; | |
| box-shadow: 0 1px 2px rgba(0,0,0,0.05) !important; | |
| transition: all 0.2s !important; | |
| color: #1f2937 !important; | |
| font-weight: 500 !important; | |
| } | |
| .module-selector label:hover { | |
| border-color: #3b82f6 !important; | |
| background: #eff6ff !important; | |
| } | |
| /* FIX: Selected state with dark background and white text */ | |
| .module-selector label:has(input:checked) { | |
| background: #2563eb !important; | |
| border-color: #1d4ed8 !important; | |
| color: white !important; | |
| font-weight: 600 !important; | |
| } | |
| /* Action Buttons */ | |
| .update-btn { | |
| background: linear-gradient(135deg, #10b981 0%, #059669 100%) !important; | |
| color: white !important; | |
| border: none !important; | |
| font-weight: 600 !important; | |
| } | |
| .download-btn { | |
| background: linear-gradient(135deg, #6366f1 0%, #4f46e5 100%) !important; | |
| color: white !important; | |
| border: none !important; | |
| font-weight: 600 !important; | |
| } | |
| /* Dropdowns */ | |
| .filter-dropdown .wrap-inner { | |
| border: 1px solid #9ca3af !important; | |
| border-radius: 6px !important; | |
| } | |
| /* HF Mobile wraps everything in .dark, so we override that theme only */ | |
| .dark .insights-panel, | |
| .dark .insights-panel .markdown-body, | |
| .dark .insights-panel * { | |
| color: #0a0a0a !important; /* Force dark readable text */ | |
| fill: #0a0a0a !important; /* Fix icon / emoji fill if SVG */ | |
| } | |
| /* Also ensure background stays light even in dark mode */ | |
| .dark .insights-panel { | |
| background: linear-gradient(135deg, #f0f9ff 0%, #e0f2fe 100%) !important; | |
| border-left: 4px solid #0284c7 !important; | |
| } | |
| /* Fix headings and strong text */ | |
| .dark .insights-panel h1, | |
| .dark .insights-panel h2, | |
| .dark .insights-panel h3, | |
| .dark .insights-panel strong { | |
| color: #000 !important; | |
| } | |
| """ | |
| with gr.Blocks(title="Hydro-Agro Dashboard", theme=gr.themes.Soft(primary_hue="blue"), css=css) as app: | |
| # Header | |
| with gr.Row(): | |
| gr.Markdown("## 🌊 Hydro-Agro Intelligence Dashboard") | |
| # Context Row: Map + Load | |
| with gr.Row(equal_height=True): | |
| with gr.Column(scale=1): | |
| gr.HTML( | |
| value=f'<div class="map-container" style="height: 280px;">{initial_map_html}</div>', | |
| label="Watershed Location" | |
| ) | |
| with gr.Column(scale=1): | |
| with gr.Group(elem_classes="load-container"): | |
| gr.Markdown("### 📁 Data Source") | |
| with gr.Row(): | |
| use_sample = gr.Checkbox(label="Use Sample Data (2025)", value=True) | |
| file_input = gr.File(label="Upload CSV", file_types=[".csv"], height=80) | |
| load_btn = gr.Button("▶ Load & Analyze Data", variant="primary", size="lg") | |
| load_status = gr.Markdown("System Ready. Please load data.") | |
| gr.Markdown("---") | |
| # Main Workspace | |
| with gr.Row(): | |
| # Sidebar: Controls | |
| with gr.Column(scale=1, min_width=280): | |
| # Filters Panel | |
| with gr.Group(visible=False) as filter_group: | |
| gr.Markdown("### 🛠 Time Filters") | |
| aggregation = gr.Dropdown( | |
| label="Time Step", | |
| choices=["15min", "Hourly", "Daily", "Weekly", "Monthly"], | |
| value="Daily", | |
| elem_classes="filter-dropdown" | |
| ) | |
| with gr.Row(): | |
| start_date = gr.Textbox(label="Start", value="2025-01-01") | |
| end_date = gr.Textbox(label="End", value="2025-06-30") | |
| apply_btn = gr.Button("↻ Update View", elem_classes="update-btn") | |
| # Analysis Panel | |
| with gr.Group(visible=False) as analysis_group: | |
| gr.Markdown("### 🧠 Analysis Modules") | |
| analysis_type = gr.Radio( | |
| choices=["Hydroclimate Overview", "Recharge Analysis", "Agricultural Stress", "Sensor QC"], | |
| value="Hydroclimate Overview", | |
| label="Select Module", | |
| elem_classes="module-selector" | |
| ) | |
| analyze_btn = gr.Button("🚀 Run Analysis", variant="primary") | |
| gr.Markdown("### 📥 Export Reports") | |
| export_fmt = gr.Radio(["CSV", "Excel", "Report"], value="CSV", label="Format") | |
| export_btn = gr.Button("💾 Download Results", elem_classes="download-btn") | |
| export_file = gr.File(visible=False) | |
| # Main Visualization Area | |
| with gr.Column(scale=3): | |
| main_plot = gr.Plot(label="Data Visualization") | |
| with gr.Row(): | |
| with gr.Column(scale=2): | |
| results_text = gr.Markdown("") | |
| metrics_table = gr.Dataframe(label="Key Indicators", visible=False) | |
| with gr.Column(scale=1): | |
| # Policy Insights Panel | |
| insights_panel = gr.Markdown( | |
| "", | |
| elem_classes="insights-panel" | |
| ) | |
| # Event Wiring - FIXED: Pass aggregation to run_analysis | |
| load_btn.click( | |
| fn=load_and_initialize, | |
| inputs=[file_input, use_sample], | |
| outputs=[load_status, main_plot, filter_group, analysis_group, | |
| results_text, metrics_table, metrics_table, insights_panel, | |
| start_date, end_date] | |
| ) | |
| apply_btn.click( | |
| fn=apply_filters, | |
| inputs=[aggregation, start_date, end_date], | |
| outputs=[load_status, main_plot] | |
| ) | |
| # AUTO-UPDATE: When aggregation dropdown changes, automatically update the view | |
| aggregation.change( | |
| fn=apply_filters, | |
| inputs=[aggregation, start_date, end_date], | |
| outputs=[load_status, main_plot] | |
| ) | |
| # CRITICAL FIX: Pass aggregation as input to run_analysis | |
| analyze_btn.click( | |
| fn=run_analysis, | |
| inputs=[analysis_type, aggregation], # ← ADDED aggregation input | |
| outputs=[results_text, main_plot, metrics_table, insights_panel] | |
| ).then(lambda: gr.update(visible=True), outputs=[metrics_table]) | |
| export_btn.click( | |
| fn=export_data, | |
| inputs=[export_fmt], | |
| outputs=[load_status, export_file] | |
| ).then(lambda x: gr.update(visible=True, value=x) if x else gr.update(visible=False), | |
| inputs=[export_file], outputs=[export_file]) | |
| return app | |
| if __name__ == "__main__": | |
| app = create_app() | |
| app.launch(server_name="0.0.0.0", server_port=7860, share=False, show_error=True) |