Update app.py

app.py

@@ -6,16 +6,16 @@ import plotly.graph_objects as go
 import gradio as gr
 from datetime import datetime
 
-# Constants - Updated for NASA's new format
+# Constants
 NASA_DATA_URL = "https://data.giss.nasa.gov/gistemp/tabledata_v4/GLB.Ts+dSST.csv"
 CURRENT_YEAR = datetime.now().year
 MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 
           'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
 
 def load_and_process_data():
-    """Load and process NASA temperature data with updated format handling"""
+    """Load and process NASA temperature data"""
     try:
-        # Read NASA data with updated parameters
+        # Read NASA data
         df = pd.read_csv(
             NASA_DATA_URL,
             skiprows=1,
@@ -23,18 +23,12 @@ def load_and_process_data():
             engine='python'
         )
         
-        # Clean and reshape data - handle new column format
+        # Clean and reshape data
         df = df[df['Year'] >= 1880]
-        
-        # Select only year and month columns (new format uses month names)
         df = df[['Year'] + MONTHS]
         
-        # Melt to long format using month names
-        df = df.melt(
-            id_vars='Year', 
-            var_name='Month', 
-            value_name='Anomaly'
-        )
+        # Melt to long format
+        df = df.melt(id_vars='Year', var_name='Month', value_name='Anomaly')
         
         # Convert month names to numeric values
         month_map = {name: f"{i:02d}" for i, name in enumerate(MONTHS, 1)}
@@ -43,11 +37,12 @@ def load_and_process_data():
         # Create date column
         df['Date'] = pd.to_datetime(
             df['Year'].astype(str) + '-' + df['Month_Num'],
-            format='%Y-%m'
+            format='%Y-%m',
+            errors='coerce'
         )
         
         # Clean and process anomalies
-        df = df.dropna(subset=['Anomaly'])
+        df = df.dropna(subset=['Anomaly', 'Date'])
         df['Anomaly'] = df['Anomaly'].astype(float)
         df['Decade'] = (df['Year'] // 10) * 10
         
@@ -62,7 +57,7 @@ def load_and_process_data():
         print(f"Data loading error: {e}")
         return pd.DataFrame()
 
-# ... [rest of visualization functions remain unchanged] ...
+# Visualization functions remain the same as before
 
 def create_dashboard():
     """Create Gradio dashboard with fixed components"""
@@ -70,74 +65,80 @@ def create_dashboard():
     
     with gr.Blocks(title="NASA Climate Viz", theme=gr.themes.Soft()) as demo:
         gr.Markdown("# 🌍 Earth's Surface Temperature Analysis")
+        gr.Markdown("### Visualization of NASA's Global Temperature Data")
         
-        # ... [header remains unchanged] ...
+        with gr.Row():
+            gr.Markdown(f"""
+            **Data Source**: [NASA Goddard Institute for Space Studies](https://data.giss.nasa.gov/gistemp/)  
+            **Last Update**: {CURRENT_YEAR}  
+            **Base Period**: 1951-1980
+            """)
         
         with gr.Tab("Time Series Analysis"):
             gr.Markdown("## Global Temperature Anomalies Over Time")
             with gr.Row():
-                show_uncertainty = gr.Checkbox(label="Show Uncertainty Bands")
-                # FIXED: Use new Slider syntax with range=True
-                year_range = gr.Slider(
-                    minimum=1880,
-                    maximum=CURRENT_YEAR,
-                    value=[1950, CURRENT_YEAR],
-                    label="Year Range",
-                    step=1,
-                    interactive=True,
-                    range=True  # This creates dual-handle range slider
+                show_uncertainty = gr.Checkbox(label="Show Uncertainty Bands", value=False)
+            
+            with gr.Row():
+                min_year = gr.Slider(
+                    1880, CURRENT_YEAR, value=1950, 
+                    label="Start Year", step=1
                 )
+                max_year = gr.Slider(
+                    1880, CURRENT_YEAR, value=CURRENT_YEAR, 
+                    label="End Year", step=1
+                )
+            
             time_series = gr.Plot()
         
         with gr.Tab("Decadal Heatmap"):
             gr.Markdown("## Monthly Anomalies by Decade")
-            # FIXED: Updated slider syntax
-            decade_range = gr.Slider(
-                minimum=1880,
-                maximum=CURRENT_YEAR - (CURRENT_YEAR % 10),
-                value=[1950, CURRENT_YEAR - (CURRENT_YEAR % 10)],
-                step=10,
-                label="Decade Range",
-                interactive=True,
-                range=True  # Dual-handle range slider
-            )
+            with gr.Row():
+                min_decade = gr.Slider(
+                    1880, CURRENT_YEAR, value=1950, 
+                    label="Start Decade", step=10
+                )
+                max_decade = gr.Slider(
+                    1880, CURRENT_YEAR, value=CURRENT_YEAR, 
+                    label="End Decade", step=10
+                )
             heatmap = gr.Plot()
         
         # ... [other tabs remain unchanged] ...
         
-        # Event handling with fixed input parameters
-        show_uncertainty.change(
-            fn=lambda u, y: create_time_series_plot(
-                df[(df['Year'] >= y[0]) & (df['Year'] <= y[1])],
-                u
-            ),
-            inputs=[show_uncertainty, year_range],
-            outputs=time_series
-        )
-        
-        year_range.input(  # Use .input instead of .change for realtime updates
-            fn=lambda y, u: create_time_series_plot(
-                df[(df['Year'] >= y[0]) & (df['Year'] <= y[1])],
-                u
-            ),
-            inputs=[year_range, show_uncertainty],
-            outputs=time_series
-        )
+        # Helper functions for updates
+        def update_time_series(show_unc, min_yr, max_yr):
+            filtered = df[(df['Year'] >= min_yr) & (df['Year'] <= max_yr)]
+            return create_time_series_plot(filtered, show_unc)
+        
+        def update_heatmap(min_dec, max_dec):
+            return create_heatmap(df, (min_dec, max_dec))
+        
+        # Event handling
+        inputs = [show_uncertainty, min_year, max_year]
+        for component in inputs:
+            component.change(
+                update_time_series,
+                inputs=inputs,
+                outputs=time_series
+            )
         
-        decade_range.input(
-            fn=lambda dr: create_heatmap(df, (dr[0], dr[1])),
-            inputs=decade_range,
-            outputs=heatmap
-        )
+        decade_inputs = [min_decade, max_decade]
+        for component in decade_inputs:
+            component.change(
+                update_heatmap,
+                inputs=decade_inputs,
+                outputs=heatmap
+            )
         
         # Initial renders
         demo.load(
-            fn=lambda: create_time_series_plot(df[(df['Year'] >= 1950) & (df['Year'] <= CURRENT_YEAR)]),
+            fn=lambda: update_time_series(False, 1950, CURRENT_YEAR),
             outputs=time_series
         )
         
         demo.load(
-            fn=lambda: create_heatmap(df, (1950, CURRENT_YEAR)),
+            fn=lambda: update_heatmap(1950, CURRENT_YEAR),
             outputs=heatmap
         )