Update air_quality_map.py

air_quality_map.py

@@ -14,6 +14,7 @@ API_KEY = os.environ.get("EPA_AQS_API_KEY", "")  # Get from environment variable
 
 class AirQualityApp:
     def __init__(self):
+        # [Keep all your existing initialization code the same]
         self.states = {
             "AL": "Alabama", "AK": "Alaska", "AZ": "Arizona", "AR": "Arkansas", 
             "CA": "California", "CO": "Colorado", "CT": "Connecticut", "DE": "Delaware", 
@@ -98,9 +99,61 @@ class AirQualityApp:
             {"code": "42602", "value_represented": "Nitrogen dioxide"},
             {"code": "81102", "value_represented": "PM10 - Local Conditions"}
         ]
+        
+        # Mock air quality data for demo
+        self.mock_aqi_data = {
+            "CA": self._generate_mock_aqi_data("CA"),
+            "NY": self._generate_mock_aqi_data("NY"),
+            "TX": self._generate_mock_aqi_data("TX")
+        }
     
+    def _generate_mock_aqi_data(self, state_code):
+        """Generate mock AQI data for a state"""
+        import random
+        from datetime import datetime, timedelta
+        
+        aqi_data = []
+        
+        # Get numeric state code
+        numeric_state_code = self.state_code_mapping.get(state_code, "01")
+        
+        # Generate data for the most recent 7 days
+        for days_ago in range(7):
+            # Generate date
+            date = (datetime.now() - timedelta(days=days_ago)).strftime("%Y-%m-%d")
+            
+            # Generate random data for each county in the state
+            counties = self.mock_counties.get(state_code, [{"code": "001", "value": "County 1"}])
+            for county in counties:
+                county_code = county["code"]
+                
+                # Generate data for each parameter
+                for param in self.mock_parameters:
+                    param_code = param["code"]
+                    param_name = param["value_represented"]
+                    
+                    # Generate a few site numbers per county
+                    for site_num in range(1, 4):
+                        site_number = f"{site_num:04d}"
+                        
+                        # Generate random AQI value (between 0 and 300)
+                        aqi_value = random.randint(0, 300)
+                        
+                        aqi_data.append({
+                            "state_code": numeric_state_code,
+                            "county_code": county_code,
+                            "site_number": site_number,
+                            "parameter_code": param_code,
+                            "parameter_name": param_name,
+                            "date_local": date,
+                            "aqi": aqi_value
+                        })
+        
+        return aqi_data
+    
+    # [Keep all your existing methods the same]
     def get_monitors(self, state_code, county_code=None, parameter_code=None):
-        """Fetch monitoring stations for a given state and optional county"""
+        # [Same as original]
         # If we don't have API credentials, use mock data
         if not EMAIL or not API_KEY:
             return self.mock_get_monitors(state_code, county_code, parameter_code)
@@ -154,8 +207,9 @@ class AirQualityApp:
         except Exception as e:
             print(f"Error fetching monitors: {e}")
             return self.mock_get_monitors(state_code, county_code, parameter_code)
-
+    
     def get_counties(self, state_code):
+        # [Same as original]
         """Fetch counties for a given state"""
         # If we don't have API credentials, use mock data
         if not EMAIL or not API_KEY:
@@ -195,8 +249,9 @@ class AirQualityApp:
         except Exception as e:
             print(f"Error fetching counties: {e}")
             return []
-
+    
     def get_parameters(self):
+        # [Same as original]
         """Fetch available parameter codes (pollutants)"""
         # If we don't have API credentials, use mock data
         if not EMAIL or not API_KEY:
@@ -241,7 +296,20 @@ class AirQualityApp:
         """Fetch the latest AQI data for monitors"""
         # If we don't have API credentials, use mock data
         if not EMAIL or not API_KEY:
-            return []  # We don't have mock AQI data for simplicity
+            # Use mock data for demo
+            if state_code in self.mock_aqi_data:
+                aqi_data = self.mock_aqi_data[state_code]
+                
+                # Filter by county if provided
+                if county_code:
+                    aqi_data = [item for item in aqi_data if item.get('county_code') == county_code]
+                
+                # Filter by parameter if provided
+                if parameter_code:
+                    aqi_data = [item for item in aqi_data if item.get('parameter_code') == parameter_code]
+                
+                return aqi_data
+            return []
         
         # Convert state code to numeric format for API
         api_state_code = state_code
@@ -293,7 +361,7 @@ class AirQualityApp:
         monitors = self.get_monitors(state_code, parameter_code=parameter_code)
         
         if not monitors:
-            return "No monitoring stations found for the selected criteria."
+            return {"map": "No monitoring stations found for the selected criteria.", "legend": "", "data": None}
         
         # Convert to DataFrame for easier manipulation
         df = pd.DataFrame(monitors)
@@ -306,29 +374,32 @@ class AirQualityApp:
             print(f"After filtering, {len(df)} monitors remain")
             
             if len(df) == 0:
-                return "No monitoring stations found for the selected county."
+                return {"map": "No monitoring stations found for the selected county.", "legend": "", "data": None}
         
         # Create a map centered on the mean latitude and longitude
         center_lat = df["latitude"].mean()
         center_lon = df["longitude"].mean()
         
         # Create a map with a specific width and height - make it bigger
-        m = folium.Map(location=[center_lat, center_lon], zoom_start=7, width='100%', height=700)
+        m = folium.Map(location=[center_lat, center_lon], zoom_start=7, width='100%', height=500)
         
         # Add a marker cluster
         marker_cluster = MarkerCluster().add_to(m)
         
         # Get latest AQI data if credentials are provided
         aqi_data = {}
-        if EMAIL and API_KEY:
-            # Again, don't pass county_code to API
-            aqi_results = self.get_latest_aqi(state_code, parameter_code=parameter_code)
-            # Create a lookup dictionary by site ID
-            for item in aqi_results:
-                site_id = f"{item['state_code']}-{item['county_code']}-{item['site_number']}"
-                if site_id not in aqi_data:
-                    aqi_data[site_id] = []
-                aqi_data[site_id].append(item)
+        all_aqi_readings = []
+        
+        # Get AQI data either from API or mock data
+        aqi_results = self.get_latest_aqi(state_code, county_code, parameter_code)
+        
+        # Create a lookup dictionary by site ID
+        for item in aqi_results:
+            site_id = f"{item['state_code']}-{item['county_code']}-{item['site_number']}"
+            if site_id not in aqi_data:
+                aqi_data[site_id] = []
+            aqi_data[site_id].append(item)
+            all_aqi_readings.append(item)
         
         # Add markers for each monitoring station
         for _, row in df.iterrows():
@@ -415,15 +486,18 @@ class AirQualityApp:
                 icon=folium.Icon(color=color, icon="cloud"),
             ).add_to(marker_cluster)
         
-        # Return map HTML and legend HTML separately
+        # Return map HTML, legend HTML, and data for the separate panel
         map_html = m._repr_html_()
-        
-        # Create legend HTML outside the map
         legend_html = self.create_legend_html()
         
-        return {"map": map_html, "legend": legend_html}
+        return {
+            "map": map_html, 
+            "legend": legend_html,
+            "data": all_aqi_readings
+        }
     
     def create_legend_html(self):
+        # [Same as original]
         """Create the HTML for the AQI legend"""
         legend_html = """
         <div style="padding: 10px; border: 1px solid #ccc; border-radius: 5px; background-color: white; margin-top: 10px;">
@@ -442,21 +516,95 @@ class AirQualityApp:
         return legend_html
     
     def get_aqi_category(self, aqi_value):
+        # [Same as original]
         """Determine AQI category based on value"""
-        aqi = int(aqi_value)
-        if aqi <= 50:
-            return "Good"
-        elif aqi <= 100:
-            return "Moderate"
-        elif aqi <= 150:
-            return "Unhealthy for Sensitive Groups"
-        elif aqi <= 200:
-            return "Unhealthy"
-        elif aqi <= 300:
-            return "Very Unhealthy"
-        else:
-            return "Hazardous"
+        try:
+            aqi = int(aqi_value)
+            if aqi <= 50:
+                return "Good"
+            elif aqi <= 100:
+                return "Moderate"
+            elif aqi <= 150:
+                return "Unhealthy for Sensitive Groups"
+            elif aqi <= 200:
+                return "Unhealthy"
+            elif aqi <= 300:
+                return "Very Unhealthy"
+            else:
+                return "Hazardous"
+        except (ValueError, TypeError):
+            return "Unknown"
+    
+    def format_air_quality_data_table(self, aqi_data):
+        """Format air quality data as an HTML table for display"""
+        if not aqi_data or len(aqi_data) == 0:
+            return "<p>No air quality data available for the selected criteria.</p>"
+        
+        # Sort by date (most recent first) and then by AQI value (highest first)
+        sorted_data = sorted(aqi_data, 
+                            key=lambda x: (x.get('date_local', ''), -int(x.get('aqi', 0)) if x.get('aqi') and str(x.get('aqi')).isdigit() else 0), 
+                            reverse=True)
+        
+        # Group by location to show the latest readings for each site
+        site_data = {}
+        for item in sorted_data:
+            site_id = f"{item.get('state_code', '')}-{item.get('county_code', '')}-{item.get('site_number', '')}"
+            param = item.get('parameter_code', '')
+            key = f"{site_id}-{param}"
+            
+            if key not in site_data:
+                site_data[key] = item
+        
+        # Create HTML table
+        html = """
+        <div style="max-height: 500px; overflow-y: auto;">
+            <h3>Latest Air Quality Readings</h3>
+            <table style="width:100%; border-collapse: collapse;">
+                <tr style="background-color: #f2f2f2; position: sticky; top: 0;">
+                    <th style="padding: 8px; text-align: left; border: 1px solid #ddd;">Date</th>
+                    <th style="padding: 8px; text-align: left; border: 1px solid #ddd;">Location</th>
+                    <th style="padding: 8px; text-align: left; border: 1px solid #ddd;">Pollutant</th>
+                    <th style="padding: 8px; text-align: left; border: 1px solid #ddd;">AQI</th>
+                    <th style="padding: 8px; text-align: left; border: 1px solid #ddd;">Category</th>
+                </tr>
+        """
+        
+        # Add rows for each site's latest readings
+        for i, item in enumerate(site_data.values()):
+            date = item.get('date_local', 'N/A')
+            
+            # Try to get a nice location name
+            state_code = item.get('state_code', 'N/A')
+            county_code = item.get('county_code', 'N/A')
+            site_number = item.get('site_number', 'N/A')
+            location = f"Site {state_code}-{county_code}-{site_number}"
+            
+            pollutant = item.get('parameter_name', 'N/A')
+            aqi_value = item.get('aqi', 'N/A')
+            category = self.get_aqi_category(aqi_value)
+            
+            # Get appropriate color for the AQI category
+            category_color = self.aqi_legend_colors.get(category, "#cccccc")
+            
+            row_style = ' style="background-color: #f9f9f9;"' if i % 2 == 0 else ''
+            html += f"""
+            <tr{row_style}>
+                <td style="padding: 8px; text-align: left; border: 1px solid #ddd;">{date}</td>
+                <td style="padding: 8px; text-align: left; border: 1px solid #ddd;">{location}</td>
+                <td style="padding: 8px; text-align: left; border: 1px solid #ddd;">{pollutant}</td>
+                <td style="padding: 8px; text-align: left; border: 1px solid #ddd;">{aqi_value}</td>
+                <td style="padding: 8px; text-align: left; border: 1px solid #ddd; background-color: {category_color};">{category}</td>
+            </tr>
+            """
+        
+        html += """
+            </table>
+        </div>
+        """
+        
+        return html
     
+    # [Keep all your mock data methods the same]
     def mock_get_counties(self, state_code):
         """Return mock county data for the specified state"""
         if state_code in self.mock_counties:
@@ -488,6 +636,7 @@ class AirQualityApp:
             numeric_state_code = state_code_mapping.get(state_code, "01")  # Default to "01" if not found
         else:
             numeric_state_code = state_code
+        
         # Sample data for California
         if state_code == "CA" or numeric_state_code == "06":
             monitors = [
@@ -675,8 +824,9 @@ class AirQualityApp:
             
         return monitors
 
+# Create the UI with the new Air Quality Data panel
 def create_air_quality_map_ui():
-    """Create the Gradio interface for the Air Quality Map application"""
+    """Create the Gradio interface for the Air Quality Map application with a separate data panel"""
     app = AirQualityApp()
     
     def update_counties(state_code):
@@ -684,8 +834,8 @@ def create_air_quality_map_ui():
         counties = app.get_counties(state_code)
         return gr.Dropdown(choices=counties)
     
-    def show_map(state, county=None, parameter=None):
-        """Callback to generate and display the map"""
+    def show_map_and_data(state, county=None, parameter=None):
+        """Callback to generate and display both the map and the air quality data"""
         # Extract code from county string if provided
         county_code = None
         if county and ":" in county:
@@ -696,27 +846,35 @@ def create_air_quality_map_ui():
         if parameter and ":" in parameter:
             parameter_code = parameter.split(":")[0].strip()
             
-        # Generate the map
+        # Generate the map and get data
         result = app.create_map(state, county_code, parameter_code)
         
         if isinstance(result, dict):
-            # Combine map and legend HTML
-            html_content = f"""
+            # Process map HTML
+            map_html = f"""
             <div>
                 {result["map"]}
                 {result["legend"]}
             </div>
             """
-            return html_content
+            
+            # Process air quality data for the separate panel
+            if result["data"]:
+                data_html = app.format_air_quality_data_table(result["data"])
+            else:
+                data_html = "<p>No air quality data available for the selected criteria.</p>"
+                
+            return map_html, data_html
         else:
             # Return error message or whatever was returned
-            return result
+            error_message = result if isinstance(result, str) else "An error occurred"
+            return error_message, "<p>No data available</p>"
     
     # Create the UI
     with gr.Blocks(title="Air Quality Monitoring Stations") as interface:
         gr.Markdown("# NOAA Air Quality Monitoring Stations Map")
         gr.Markdown("""
-        This application displays air quality monitoring stations in the United States.
+        This application displays air quality monitoring stations in the United States and shows current air quality readings.
         
         **Note:** To use the actual EPA AQS API, you need to register for an API key and set 
         `EPA_AQS_EMAIL` and `EPA_AQS_API_KEY` environment variables in your Hugging Face Space.
@@ -747,12 +905,18 @@ def create_air_quality_map_ui():
                     allow_custom_value=True
                 )
                 
-                # Button to generate map
-                map_button = gr.Button("Show Map")
-            
-            # HTML component to display the map in a larger column
-            with gr.Column(scale=3):
+                # Button to generate map and data
+                map_button = gr.Button("Show Map and Air Quality Data")
+        
+        # Create two tabs for the map and data
+        with gr.Tabs() as tabs:
+            with gr.TabItem("Map"):
+                # HTML component to display the map
                 map_html = gr.HTML(label="Air Quality Monitoring Stations Map")
+            
+            with gr.TabItem("Air Quality Data"):
+                # HTML component to display the air quality data
+                data_html = gr.HTML(label="Air Quality Readings")
         
         # Set up event handlers
         state_dropdown.change(
@@ -762,9 +926,9 @@ def create_air_quality_map_ui():
         )
         
         map_button.click(
-            fn=show_map,
+            fn=show_map_and_data,
             inputs=[state_dropdown, county_dropdown, parameter_dropdown],
-            outputs=map_html
+            outputs=[map_html, data_html]
         )
     
     return interface