Delete air_quality_map.py

air_quality_map.py

@@ -1,781 +0,0 @@
-import gradio as gr
-import requests
-import pandas as pd
-import folium
-from folium.plugins import MarkerCluster
-import tempfile
-import os
-import json
-
-# Get API credentials from environment variables
-EPA_AQS_API_BASE_URL = "https://aqs.epa.gov/data/api"
-EMAIL = os.environ.get("EPA_AQS_EMAIL", "")  # Get from environment variable
-API_KEY = os.environ.get("EPA_AQS_API_KEY", "")  # Get from environment variable
-
-class AirQualityApp:
-    def __init__(self):
-        self.states = {
-            "AL": "Alabama", "AK": "Alaska", "AZ": "Arizona", "AR": "Arkansas", 
-            "CA": "California", "CO": "Colorado", "CT": "Connecticut", "DE": "Delaware", 
-            "FL": "Florida", "GA": "Georgia", "HI": "Hawaii", "ID": "Idaho", 
-            "IL": "Illinois", "IN": "Indiana", "IA": "Iowa", "KS": "Kansas", 
-            "KY": "Kentucky", "LA": "Louisiana", "ME": "Maine", "MD": "Maryland", 
-            "MA": "Massachusetts", "MI": "Michigan", "MN": "Minnesota", "MS": "Mississippi", 
-            "MO": "Missouri", "MT": "Montana", "NE": "Nebraska", "NV": "Nevada", 
-            "NH": "New Hampshire", "NJ": "New Jersey", "NM": "New Mexico", "NY": "New York", 
-            "NC": "North Carolina", "ND": "North Dakota", "OH": "Ohio", "OK": "Oklahoma", 
-            "OR": "Oregon", "PA": "Pennsylvania", "RI": "Rhode Island", "SC": "South Carolina", 
-            "SD": "South Dakota", "TN": "Tennessee", "TX": "Texas", "UT": "Utah", 
-            "VT": "Vermont", "VA": "Virginia", "WA": "Washington", "WV": "West Virginia", 
-            "WI": "Wisconsin", "WY": "Wyoming", "DC": "District of Columbia"
-        }
-        
-        # Mapping from two-letter state codes to numeric state codes for API
-        self.state_code_mapping = {
-            "AL": "01", "AK": "02", "AZ": "04", "AR": "05", 
-            "CA": "06", "CO": "08", "CT": "09", "DE": "10", 
-            "FL": "12", "GA": "13", "HI": "15", "ID": "16", 
-            "IL": "17", "IN": "18", "IA": "19", "KS": "20", 
-            "KY": "21", "LA": "22", "ME": "23", "MD": "24", 
-            "MA": "25", "MI": "26", "MN": "27", "MS": "28", 
-            "MO": "29", "MT": "30", "NE": "31", "NV": "32", 
-            "NH": "33", "NJ": "34", "NM": "35", "NY": "36", 
-            "NC": "37", "ND": "38", "OH": "39", "OK": "40", 
-            "OR": "41", "PA": "42", "RI": "44", "SC": "45", 
-            "SD": "46", "TN": "47", "TX": "48", "UT": "49", 
-            "VT": "50", "VA": "51", "WA": "53", "WV": "54", 
-            "WI": "55", "WY": "56", "DC": "11"
-        }
-        
-        # AQI categories with their corresponding colors - using only valid Folium icon colors
-        self.aqi_categories = {
-            "Good": "green",
-            "Moderate": "orange",
-            "Unhealthy for Sensitive Groups": "orange",
-            "Unhealthy": "red",
-            "Very Unhealthy": "purple",
-            "Hazardous": "darkred"
-        }
-        
-        # Color mapping for the legend (using original colors for display)
-        self.aqi_legend_colors = {
-            "Good": "#00e400",  # Green
-            "Moderate": "#ffff00",  # Yellow
-            "Unhealthy for Sensitive Groups": "#ff7e00",  # Orange
-            "Unhealthy": "#ff0000",  # Red
-            "Very Unhealthy": "#99004c",  # Purple
-            "Hazardous": "#7e0023"  # Maroon
-        }
-        
-        # Sample county data for demo
-        self.mock_counties = {
-            "CA": [
-                {"code": "037", "value": "Los Angeles"},
-                {"code": "067", "value": "Sacramento"},
-                {"code": "073", "value": "San Diego"},
-                {"code": "075", "value": "San Francisco"}
-            ],
-            "NY": [
-                {"code": "061", "value": "New York"},
-                {"code": "047", "value": "Kings (Brooklyn)"},
-                {"code": "081", "value": "Queens"},
-                {"code": "005", "value": "Bronx"}
-            ],
-            "TX": [
-                {"code": "201", "value": "Harris (Houston)"},
-                {"code": "113", "value": "Dallas"},
-                {"code": "029", "value": "Bexar (San Antonio)"},
-                {"code": "453", "value": "Travis (Austin)"}
-            ]
-        }
-        
-        # Sample parameters for demo
-        self.mock_parameters = [
-            {"code": "88101", "value_represented": "PM2.5 - Local Conditions"},
-            {"code": "44201", "value_represented": "Ozone"},
-            {"code": "42401", "value_represented": "Sulfur dioxide"},
-            {"code": "42101", "value_represented": "Carbon monoxide"},
-            {"code": "42602", "value_represented": "Nitrogen dioxide"},
-            {"code": "81102", "value_represented": "PM10 - Local Conditions"}
-        ]
-    
-    def get_monitors(self, state_code, county_code=None, parameter_code=None):
-        """Fetch monitoring stations for a given state and optional county"""
-        # 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)
-        
-        # Convert state code to numeric format for API
-        api_state_code = state_code
-        if len(state_code) == 2 and state_code in self.state_code_mapping:
-            api_state_code = self.state_code_mapping[state_code]
-            
-        # API endpoint for monitoring sites
-        endpoint = f"{EPA_AQS_API_BASE_URL}/monitors/byState"
-        
-        params = {
-            "email": EMAIL,
-            "key": API_KEY,
-            "state": api_state_code,
-            "bdate": "20240101",  # Beginning date (YYYYMMDD)
-            "edate": "20240414",  # End date (YYYYMMDD)
-        }
-        
-        if county_code:
-            params["county"] = county_code
-            
-        if parameter_code:
-            params["param"] = parameter_code
-        
-        try:
-            response = requests.get(endpoint, params=params)
-            data = response.json()
-            
-            # Add detailed debugging
-            print(f"API Response Keys: {list(data.keys()) if isinstance(data, dict) else 'Not a dictionary'}")
-            if isinstance(data, dict) and "Header" in data:
-                print(f"Header type: {type(data['Header'])}, content: {data['Header'][:100]}...")
-            
-            # Handle the specific response structure we observed
-            if isinstance(data, dict):
-                if "Data" in data and isinstance(data["Data"], list):
-                    return data["Data"]
-                elif "Header" in data and isinstance(data["Header"], list):
-                    if len(data["Header"]) > 0 and data["Header"][0].get("status") == "Success":
-                        return data.get("Data", [])
-                    else:
-                        print(f"Header does not contain success status: {data['Header']}")
-                # Special case - return mock data if we can't parse the API response
-                print(f"Using mock data instead of API response for state {state_code}")
-                return self.mock_get_monitors(state_code, county_code, parameter_code)
-            else:
-                print(f"Unexpected response format for monitors: {type(data)}")
-                return self.mock_get_monitors(state_code, county_code, parameter_code)
-        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):
-        """Fetch counties for a given state"""
-        # If we don't have API credentials, use mock data
-        if not EMAIL or not API_KEY:
-            return self.mock_get_counties(state_code)
-        
-        # Convert state code to numeric format for API
-        api_state_code = state_code
-        if len(state_code) == 2 and state_code in self.state_code_mapping:
-            api_state_code = self.state_code_mapping[state_code]
-        
-        endpoint = f"{EPA_AQS_API_BASE_URL}/list/countiesByState"
-        
-        params = {
-            "email": EMAIL,
-            "key": API_KEY,
-            "state": api_state_code
-        }
-        
-        try:
-            response = requests.get(endpoint, params=params)
-            data = response.json()
-            
-            # Handle the specific response structure we observed
-            counties = []
-            if isinstance(data, dict) and "Data" in data and isinstance(data["Data"], list):
-                counties = data["Data"]
-            
-            # Format as "code: name" for dropdown
-            result = []
-            for c in counties:
-                code = c.get("code")
-                value = c.get("value_represented")
-                if code and value:
-                    result.append(f"{code}: {value}")
-            
-            return result
-        except Exception as e:
-            print(f"Error fetching counties: {e}")
-            return []
-
-    def get_parameters(self):
-        """Fetch available parameter codes (pollutants)"""
-        # If we don't have API credentials, use mock data
-        if not EMAIL or not API_KEY:
-            return self.mock_get_parameters()
-        
-        endpoint = f"{EPA_AQS_API_BASE_URL}/list/parametersByClass"
-        
-        params = {
-            "email": EMAIL,
-            "key": API_KEY,
-            "pc": "CRITERIA"  # Filter to criteria pollutants
-        }
-        
-        try:
-            response = requests.get(endpoint, params=params)
-            data = response.json()
-            
-            # Handle the specific response structure we observed
-            parameters = []
-            if isinstance(data, dict) and "Data" in data and isinstance(data["Data"], list):
-                parameters = data["Data"]
-            
-            # Format as "code: name" for dropdown
-            result = []
-            for p in parameters:
-                code = p.get("code")
-                value = p.get("value_represented")
-                if not code:
-                    code = p.get("parameter_code")
-                if not value:
-                    value = p.get("parameter_name")
-                
-                if code and value:
-                    result.append(f"{code}: {value}")
-            
-            return result
-        except Exception as e:
-            print(f"Error fetching parameters: {e}")
-            return []
-    
-    def get_latest_aqi(self, state_code, county_code=None, parameter_code=None):
-        """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 self.mock_get_aqi_data(state_code, county_code, parameter_code)
-        
-        # Convert state code to numeric format for API
-        api_state_code = state_code
-        if len(state_code) == 2 and state_code in self.state_code_mapping:
-            api_state_code = self.state_code_mapping[state_code]
-        
-        endpoint = f"{EPA_AQS_API_BASE_URL}/dailyData/byState"
-        
-        params = {
-            "email": EMAIL,
-            "key": API_KEY,
-            "state": api_state_code,
-            "bdate": "20240314",  # Beginning date (YYYYMMDD) - last 30 days
-            "edate": "20240414",  # End date (YYYYMMDD) - current date
-        }
-        
-        # The county parameter might not be supported here either
-        # We'll filter results by county after getting them
-            
-        if parameter_code:
-            params["param"] = parameter_code
-        
-        try:
-            response = requests.get(endpoint, params=params)
-            data = response.json()
-            
-            # Add detailed debugging
-            print(f"AQI API Response Keys: {list(data.keys()) if isinstance(data, dict) else 'Not a dictionary'}")
-            if isinstance(data, dict) and "Header" in data:
-                print(f"AQI Header type: {type(data['Header'])}, content: {data['Header'][:100]}...")
-            
-            # Handle the specific response structure we observed
-            aqi_data = []
-            if isinstance(data, dict) and "Data" in data and isinstance(data["Data"], list):
-                aqi_data = data["Data"]
-            
-            # Filter by county if provided
-            if county_code and aqi_data:
-                aqi_data = [item for item in aqi_data if item.get('county_code') == county_code]
-                
-            return aqi_data
-        except Exception as e:
-            print(f"Error fetching AQI data: {e}")
-            return self.mock_get_aqi_data(state_code, county_code, parameter_code)
-    
-    def mock_get_aqi_data(self, state_code, county_code=None, parameter_code=None):
-        """Generate mock AQI data for demonstration"""
-        # Get monitors first
-        monitors = self.mock_get_monitors(state_code, county_code, parameter_code)
-        
-        # Create mock AQI data for each monitor
-        mock_aqi_data = []
-        
-        for monitor in monitors:
-            # Create 5 days of mock readings for each monitor
-            for i in range(5):
-                # Base AQI value depends on the parameter
-                base_aqi = 0
-                if monitor.get("parameter_code") == "88101":  # PM2.5
-                    base_aqi = 35
-                elif monitor.get("parameter_code") == "44201":  # Ozone
-                    base_aqi = 45
-                elif monitor.get("parameter_code") == "42401":  # SO2
-                    base_aqi = 25
-                else:
-                    base_aqi = 30
-                
-                # Vary the AQI by +/- 20 points randomly
-                import random
-                aqi_value = max(0, min(300, base_aqi + random.randint(-20, 20)))
-                
-                # Date is "2024-04-XX" where XX starts from 10 and goes back
-                date = f"2024-04-{14-i:02d}"
-                
-                mock_aqi_data.append({
-                    "state_code": monitor.get("state_code"),
-                    "county_code": monitor.get("county_code"),
-                    "site_number": monitor.get("site_number"),
-                    "parameter_code": monitor.get("parameter_code"),
-                    "parameter_name": monitor.get("parameter_name"),
-                    "date_local": date,
-                    "aqi": aqi_value,
-                    "category": self.get_aqi_category(aqi_value),
-                    "city_name": monitor.get("city_name", "Unknown"),
-                    "local_site_name": monitor.get("local_site_name", "Unknown")
-                })
-        
-        return mock_aqi_data
-    
-    def create_map_and_data(self, state_code, county_code=None, parameter_code=None):
-        """Create a map with air quality monitoring stations and separate data for display"""
-        # Get monitors (don't pass county_code to API)
-        monitors = self.get_monitors(state_code, parameter_code=parameter_code)
-        
-        if not monitors:
-            return {
-                "map": "No monitoring stations found for the selected criteria.",
-                "data_html": "",
-                "legend": ""
-            }
-        
-        # Convert to DataFrame for easier manipulation
-        df = pd.DataFrame(monitors)
-        
-        # Filter by county if provided - after getting the monitors
-        if county_code:
-            print(f"Filtering by county_code: {county_code}")
-            county_code_str = str(county_code)
-            df = df[df['county_code'].astype(str) == county_code_str]
-            print(f"After filtering, {len(df)} monitors remain")
-            
-            if len(df) == 0:
-                return {
-                    "map": "No monitoring stations found for the selected county.",
-                    "data_html": "",
-                    "legend": ""
-                }
-        
-        # 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
-        m = folium.Map(location=[center_lat, center_lon], zoom_start=7, width='100%', height=600)
-        
-        # Add a marker cluster
-        marker_cluster = MarkerCluster().add_to(m)
-        
-        # Get latest AQI data
-        if EMAIL and API_KEY:
-            aqi_results = self.get_latest_aqi(state_code, parameter_code=parameter_code)
-        else:
-            aqi_results = self.mock_get_aqi_data(state_code, county_code, parameter_code)
-        
-        # Create a lookup dictionary by site ID
-        aqi_data = {}
-        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)
-        
-        # Initialize a list to collect all air quality readings for display in UI
-        all_readings = []
-        
-        # Add markers for each monitoring station with minimal popup content
-        for _, row in df.iterrows():
-            site_id = f"{row['state_code']}-{row['county_code']}-{row['site_number']}"
-            
-            # Default marker color is blue
-            color = "blue"
-            
-            # Get AQI data for this station if available
-            station_aqi_data = aqi_data.get(site_id, [])
-            
-            # Add all readings from this station to the collected data
-            for reading in station_aqi_data:
-                all_readings.append({
-                    "site_id": site_id,
-                    "site_name": row['local_site_name'],
-                    "city": row.get('city_name', 'N/A'),
-                    "county": row.get('county_name', 'N/A'),
-                    "state": row.get('state_name', 'N/A'),
-                    "date": reading.get('date_local', 'N/A'),
-                    "pollutant": reading.get('parameter_name', 'N/A'),
-                    "aqi": reading.get('aqi', 'N/A'),
-                    "category": self.get_aqi_category(reading.get('aqi', 0)) if reading.get('aqi') else 'N/A'
-                })
-            
-            # Set marker color based on latest AQI if available
-            if station_aqi_data:
-                # Sort by date (most recent first)
-                station_aqi_data.sort(key=lambda x: x.get('date_local', ''), reverse=True)
-                
-                # Get latest AQI for marker color
-                if station_aqi_data[0].get('aqi'):
-                    latest_aqi = station_aqi_data[0].get('aqi')
-                    aqi_category = self.get_aqi_category(latest_aqi)
-                    color = self.aqi_categories.get(aqi_category, "blue")
-            
-            # Create simple popup content with just station name and link to data
-            popup_content = f"""
-            <div>
-                <h4>{row['local_site_name']}</h4>
-                <p><strong>Site ID:</strong> {site_id}</p>
-                <p>See detailed data in the panel below.</p>
-            </div>
-            """
-            
-            # Add marker to cluster with simple popup
-            popup = folium.Popup(popup_content, max_width=300)
-            folium.Marker(
-                location=[row["latitude"], row["longitude"]],
-                popup=popup,
-                icon=folium.Icon(color=color, icon="cloud"),
-            ).add_to(marker_cluster)
-        
-        # Sort all readings by date (most recent first)
-        all_readings.sort(key=lambda x: x.get('date', ''), reverse=True)
-        
-        # Convert all readings to HTML table for display in UI
-        data_html = self.create_readings_table_html(all_readings)
-        
-        # Return map HTML, data HTML, and legend HTML separately
-        return {
-            "map": m._repr_html_(),
-            "data_html": data_html,
-            "legend": self.create_legend_html()
-        }
-    
-    def create_readings_table_html(self, readings):
-        """Create an HTML table of air quality readings"""
-        if not readings:
-            return "<p>No air quality data available for the selected criteria.</p>"
-        
-        html = """
-        <div style="max-height: 500px; overflow-y: auto;">
-            <h3>Air Quality Readings</h3>
-            <table style="width:100%; border-collapse: collapse; margin-top: 10px;">
-            <tr style="background-color: #f2f2f2; position: sticky; top: 0;">
-                <th style="padding: 8px; text-align: left; border: 1px solid #ddd;">Station</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;">Date</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>
-        """
-        
-        for i, reading in enumerate(readings):
-            # Get background color for AQI category
-            category = reading.get('category', 'N/A')
-            bg_color = self.aqi_legend_colors.get(category, "#ffffff")
-            
-            # For better readability, use a lighter version of the color
-            if category != 'Good' and category != 'N/A':
-                # Add alpha transparency to the color
-                bg_color = bg_color + "40"  # 40 is 25% opacity in hex
-            
-            # Alternate row colors for better readability
-            row_style = ' style="background-color: #f9f9f9;"' if i % 2 == 0 else ''
-            
-            location = f"{reading.get('city', 'N/A')}, {reading.get('state', 'N/A')}"
-            
-            html += f"""
-            <tr{row_style}>
-                <td style="padding: 8px; text-align: left; border: 1px solid #ddd;">{reading.get('site_name', 'N/A')}</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;">{reading.get('date', 'N/A')}</td>
-                <td style="padding: 8px; text-align: left; border: 1px solid #ddd;">{reading.get('pollutant', 'N/A')}</td>
-                <td style="padding: 8px; text-align: left; border: 1px solid #ddd;">{reading.get('aqi', 'N/A')}</td>
-                <td style="padding: 8px; text-align: left; border: 1px solid #ddd; background-color: {bg_color};">{category}</td>
-            </tr>
-            """
-        
-        html += """
-            </table>
-        </div>
-        """
-        
-        return html
-    
-    def create_legend_html(self):
-        """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;">
-        <h4 style="margin-top: 0;">AQI Categories</h4>
-        <div style="display: grid; grid-template-columns: auto 1fr; grid-gap: 5px; align-items: center;">
-        """
-        
-        for category, color in self.aqi_legend_colors.items():
-            legend_html += f'<span style="background-color: {color}; width: 20px; height: 20px; display: inline-block;"></span>'
-            legend_html += f'<span>{category}</span>'
-        
-        legend_html += """
-        </div>
-        </div>
-        """
-        return legend_html
-    
-    def get_aqi_category(self, aqi_value):
-        """Determine AQI category based on value"""
-        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 "N/A"
-    
-    def mock_get_counties(self, state_code):
-        """Return mock county data for the specified state"""
-        if state_code in self.mock_counties:
-            counties = self.mock_counties[state_code]
-            return [f"{c['code']}: {c['value']}" for c in counties]
-        else:
-            # Return generic counties for other states
-            return [
-                "001: County 1",
-                "002: County 2",
-                "003: County 3",
-                "004: County 4"
-            ]
-    
-    def mock_get_parameters(self):
-        """Return mock parameter data"""
-        return [f"{p['code']}: {p['value_represented']}" for p in self.mock_parameters]
-    
-    def mock_get_monitors(self, state_code, county_code=None, parameter_code=None):
-        """Mock function to return sample data for development"""
-        # Get state code in proper format
-        if len(state_code) == 2:
-            # Convert 2-letter state code to numeric format for mock data
-            state_code_mapping = {
-                "CA": "06",
-                "NY": "36",
-                "TX": "48"
-            }
-            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 = [
-                {
-                    "state_code": "06",
-                    "county_code": "037",
-                    "site_number": "0001",
-                    "parameter_code": "88101",
-                    "parameter_name": "PM2.5 - Local Conditions",
-                    "poc": 1,
-                    "latitude": 34.0667,
-                    "longitude": -118.2275,
-                    "local_site_name": "Los Angeles - North Main Street",
-                    "address": "1630 North Main Street",
-                    "city_name": "Los Angeles",
-                    "county_name": "Los Angeles",
-                    "state_name": "California",
-                    "cbsa_name": "Los Angeles-Long Beach-Anaheim",
-                    "date_established": "1998-01-01",
-                    "last_sample_date": "2024-04-10"
-                },
-                {
-                    "state_code": "06",
-                    "county_code": "037",
-                    "site_number": "0002",
-                    "parameter_code": "44201",
-                    "parameter_name": "Ozone",
-                    "poc": 1,
-                    "latitude": 34.0667,
-                    "longitude": -118.2275,
-                    "local_site_name": "Los Angeles - North Main Street",
-                    "address": "1630 North Main Street",
-                    "city_name": "Los Angeles",
-                    "county_name": "Los Angeles",
-                    "state_name": "California",
-                    "cbsa_name": "Los Angeles-Long Beach-Anaheim",
-                    "date_established": "1998-01-01",
-                    "last_sample_date": "2024-04-10"
-                },
-                {
-                    "state_code": "06",
-                    "county_code": "067",
-                    "site_number": "0010",
-                    "parameter_code": "88101",
-                    "parameter_name": "PM2.5 - Local Conditions",
-                    "poc": 1,
-                    "latitude": 38.5661,
-                    "longitude": -121.4926,
-                    "local_site_name": "Sacramento - T Street",
-                    "address": "1309 T Street",
-                    "city_name": "Sacramento",
-                    "county_name": "Sacramento",
-                    "state_name": "California",
-                    "cbsa_name": "Sacramento-Roseville",
-                    "date_established": "1999-03-01",
-                    "last_sample_date": "2024-04-10"
-                },
-                {
-                    "state_code": "06",
-                    "county_code": "073",
-                    "site_number": "0005",
-                    "parameter_code": "88101",
-                    "parameter_name": "PM2.5 - Local Conditions",
-                    "poc": 1,
-                    "latitude": 32.7333,
-                    "longitude": -117.1500,
-                    "local_site_name": "San Diego - Beardsley Street",
-                    "address": "1110 Beardsley Street",
-                    "city_name": "San Diego",
-                    "county_name": "San Diego",
-                    "state_name": "California",
-                    "cbsa_name": "San Diego-Carlsbad",
-                    "date_established": "1999-04-15",
-                    "last_sample_date": "2024-04-10"
-                }
-            ]
-        # Sample data for New York
-        elif state_code == "NY" or numeric_state_code == "36":
-            monitors = [
-                {
-                    "state_code": "36",
-                    "county_code": "061",
-                    "site_number": "0010",
-                    "parameter_code": "88101",
-                    "parameter_name": "PM2.5 - Local Conditions",
-                    "poc": 1,
-                    "latitude": 40.7159,
-                    "longitude": -73.9876,
-                    "local_site_name": "New York - PS 59",
-                    "address": "228 East 57th Street",
-                    "city_name": "New York",
-                    "county_name": "New York",
-                    "state_name": "New York",
-                    "cbsa_name": "New York-Newark-Jersey City",
-                    "date_established": "1999-07-15",
-                    "last_sample_date": "2024-04-10"
-                },
-                {
-                    "state_code": "36",
-                    "county_code": "061",
-                    "site_number": "0079",
-                    "parameter_code": "44201",
-                    "parameter_name": "Ozone",
-                    "poc": 1,
-                    "latitude": 40.8160,
-                    "longitude": -73.9510,
-                    "local_site_name": "New York - IS 52",
-                    "address": "681 Kelly Street",
-                    "city_name": "Bronx",
-                    "county_name": "Bronx",
-                    "state_name": "New York",
-                    "cbsa_name": "New York-Newark-Jersey City",
-                    "date_established": "1998-01-01",
-                    "last_sample_date": "2024-04-10"
-                }
-            ]
-        # Sample data for Texas
-        elif state_code == "TX" or numeric_state_code == "48":
-            monitors = [
-                {
-                    "state_code": "48",
-                    "county_code": "201",
-                    "site_number": "0024",
-                    "parameter_code": "88101",
-                    "parameter_name": "PM2.5 - Local Conditions",
-                    "poc": 1,
-                    "latitude": 29.7349,
-                    "longitude": -95.3063,
-                    "local_site_name": "Houston - Clinton Drive",
-                    "address": "9525 Clinton Drive",
-                    "city_name": "Houston",
-                    "county_name": "Harris",
-                    "state_name": "Texas",
-                    "cbsa_name": "Houston-The Woodlands-Sugar Land",
-                    "date_established": "1997-09-01",
-                    "last_sample_date": "2024-04-10"
-                },
-                {
-                    "state_code": "48",
-                    "county_code": "113",
-                    "site_number": "0050",
-                    "parameter_code": "44201",
-                    "parameter_name": "Ozone",
-                    "poc": 1,
-                    "latitude": 32.8198,
-                    "longitude": -96.8602,
-                    "local_site_name": "Dallas - Hinton Street",
-                    "address": "1415 Hinton Street",
-                    "city_name": "Dallas",
-                    "county_name": "Dallas",
-                    "state_name": "Texas",
-                    "cbsa_name": "Dallas-Fort Worth-Arlington",
-                    "date_established": "1998-01-01",
-                    "last_sample_date": "2024-04-10"
-                }
-            ]
-        else:
-            # Default data for other states - generate some random monitors
-            monitors = [
-                {
-                    "state_code": state_code,
-                    "county_code": "001",
-                    "site_number": "0001",
-                    "parameter_code": "88101",
-                    "parameter_name": "PM2.5 - Local Conditions",
-                    "poc": 1,
-                    "latitude": 40.0 + float(ord(state_code[0])) / 10,
-                    "longitude": -90.0 - float(ord(state_code[1])) / 10,
-                    "local_site_name": f"{self.states.get(state_code, 'Unknown')} - Station 1",
-                    "address": "123 Main Street",
-                    "city_name": "City 1",
-                    "county_name": "County 1",
-                    "state_name": self.states.get(state_code, "Unknown"),
-                    "cbsa_name": f"{self.states.get(state_code, 'Unknown')} Metro Area",
-                    "date_established": "2000-01-01",
-                    "last_sample_date": "2024-04-10"
-                },
-                {
-                    "state_code": state_code,
-                    "county_code": "002",
-                    "site_number": "0002",
-                    "parameter_code": "44201",
-                    "parameter_name": "Ozone",
-                    "poc": 1,
-                    "latitude": 40.5 + float(ord(state_code[0])) / 10,
-                    "longitude": -90.5 - float(ord(state_code[1])) / 10,
-                    "local_site_name": f"{self.states.get(state_code, 'Unknown')} - Station 2",
-                    "address": "456 Oak Street",
-                    "city_name": "City 2",
-                    "county_name": "County 2",
-                    "state_name": self.states.get(state_code, "Unknown"),
-                    "cbsa_name": f"{self.states.get(state_code, 'Unknown')} Metro Area",
-                    "date_established": "2000-01-01",
-                    "last_sample_date": "2024-04-10"
-                }
-            ]
-        
-        # Filter by county if provided
-        if county_code:
-            monitors = [m for m in monitors if m["county_code"] == county_code]
-            
-        # Filter by parameter if provided
-        if parameter_code:
-            monitors = [m for m in monitors if m["parameter_code"] == parameter_code]
-            
-        return monitors