Update app.py

app.py

@@ -9,6 +9,7 @@ from streamlit_folium import folium_static
 import numpy as np
 import time
 from datetime import datetime, timedelta
+import pytz
 
 
 # api keys
@@ -16,6 +17,7 @@ OPENWEATHER_API_KEY = "c6c267b301a145ddec9b381e7d87a5af"
 STORMGLASS_API_KEY = "bcabf6a8-0641-11f0-a4a9-0242ac130003-bcabf72a-0641-11f0-a4a9-0242ac130003"
 
 
+
 # Page Configuration
 st.set_page_config(page_title="Environmental Data Dashboard", layout="wide")
 
@@ -23,39 +25,75 @@ st.set_page_config(page_title="Environmental Data Dashboard", layout="wide")
 st.sidebar.title("🌍 Environmental Data Dashboard")
 data_source = st.sidebar.selectbox(
     "Select Data Source", 
-    ["OpenWeather", "Stormglass", "Air Quality", "Marine Forecast"]
+    ["OpenWeather Historical", "Stormglass", "Solunar & Tide Data", "Air Quality"]
 )
 
-# OpenWeather Data Fetching Function
-def fetch_openweather_data(lat, lon):
+# OpenWeather Historical Data Fetching Function
+def fetch_openweather_historical_data(lat, lon, datetime_input):
+    """
+    Fetch historical weather data for a specific latitude, longitude, and datetime
+    """
+    # Validate datetime range (Time Machine API only supports past 5 days)
+    now = datetime.now()
+    five_days_ago = now - timedelta(days=5)
+    
+    if datetime_input > now or datetime_input < five_days_ago:
+        st.error("Historical data is only available for the past 5 days.")
+        return None
+    
+    # Convert datetime to Unix timestamp
+    timestamp = int(datetime_input.timestamp())
+    
+    # Construct API URL
+    url = f"https://api.openweathermap.org/data/2.5/onecall/timemachine?lat={lat}&lon={lon}&dt={timestamp}&appid={OPENWEATHER_API_KEY}&units=metric"
+    
     try:
-        # Current Weather
-        current_url = f"https://api.openweathermap.org/data/2.5/weather?lat={lat}&lon={lon}&appid={OPENWEATHER_API_KEY}&units=metric"
-        current_response = requests.get(current_url)
-        current_data = current_response.json()
-
-        # Forecast
-        forecast_url = f"https://api.openweathermap.org/data/2.5/forecast?lat={lat}&lon={lon}&appid={OPENWEATHER_API_KEY}&units=metric"
-        forecast_response = requests.get(forecast_url)
-        forecast_data = forecast_response.json()
-
-        return current_data, forecast_data
-    except Exception as e:
-        st.error(f"Error fetching OpenWeather data: {e}")
-        return None, None
+        # Send request to OpenWeather API
+        response = requests.get(url)
+        response.raise_for_status()
+        
+        # Parse JSON response
+        data = response.json()
+        
+        # Validate response structure
+        if not data or 'current' not in data:
+            st.error("No historical data available for the specified time.")
+            return None
+        
+        return data
+    
+    except requests.exceptions.RequestException as e:
+        st.error(f"Error fetching historical weather data: {e}")
+        return None
 
 # Stormglass Data Fetching Function
-def fetch_stormglass_data(lat, lon, start_date, end_date):
+def fetch_stormglass_comprehensive_data(lat, lon, datetime_input):
+    """
+    Fetch comprehensive marine and environmental data from Stormglass
+    """
     try:
+        # Prepare start and end times (1 day range)
+        start_time = datetime_input - timedelta(hours=12)
+        end_time = datetime_input + timedelta(hours=12)
+        
         headers = {
             'Authorization': STORMGLASS_API_KEY
         }
+        
+        # Comprehensive parameters
         params = {
             'lat': lat,
             'lng': lon,
-            'params': 'waveHeight,windSpeed,windDirection,waterTemperature,airTemperature',
-            'start': start_date.isoformat(),
-            'end': end_date.isoformat()
+            'params': ','.join([
+                'waveHeight', 'wavePeriod', 'waveDirection',
+                'windSpeed', 'windDirection',
+                'waterTemperature', 'airTemperature',
+                'seaLevel', 'currentSpeed', 'currentDirection',
+                'precipitation', 'cloudCover', 'visibility',
+                'humidity', 'pressure'
+            ]),
+            'start': start_time.isoformat(),
+            'end': end_time.isoformat()
         }
         
         response = requests.get(
@@ -65,18 +103,52 @@ def fetch_stormglass_data(lat, lon, start_date, end_date):
         )
         
         return response.json()
+    
     except Exception as e:
         st.error(f"Error fetching Stormglass data: {e}")
         return None
 
-# Air Quality Data Fetching Function
-def fetch_air_quality_data(lat, lon):
+# Solunar and Tide Data Fetching Function
+def fetch_solunar_tide_data(lat, lon, datetime_input):
+    """
+    Fetch solunar and tide data for a specific location and time
+    """
     try:
-        url = f"http://api.openweathermap.org/data/2.5/air_pollution?lat={lat}&lon={lon}&appid={OPENWEATHER_API_KEY}"
-        response = requests.get(url)
-        return response.json()
+        # Stormglass Tide API
+        headers = {
+            'Authorization': STORMGLASS_API_KEY
+        }
+        
+        params = {
+            'lat': lat,
+            'lng': lon,
+            'date': datetime_input.date().isoformat()
+        }
+        
+        # Tide data
+        tide_response = requests.get(
+            'https://api.stormglass.io/v2/tide/extremes/point', 
+            headers=headers, 
+            params=params
+        )
+        
+        # Astronomy data (for sunrise/sunset)
+        astronomy_response = requests.get(
+            'https://api.stormglass.io/v2/astronomy/point', 
+            headers=headers, 
+            params=params
+        )
+        
+        tide_data = tide_response.json() if tide_response.status_code == 200 else None
+        astronomy_data = astronomy_response.json() if astronomy_response.status_code == 200 else None
+        
+        return {
+            'tide': tide_data,
+            'astronomy': astronomy_data
+        }
+    
     except Exception as e:
-        st.error(f"Error fetching Air Quality data: {e}")
+        st.error(f"Error fetching Solunar and Tide data: {e}")
         return None
 
 # Main Application Logic
@@ -87,11 +159,19 @@ def main():
     
     with col1:
         lat = st.number_input("Latitude", value=25.7617, format="%.4f")
-        st.write(f"Selected Latitude: {lat}")
     
     with col2:
         lon = st.number_input("Longitude", value=-80.1918, format="%.4f")
-        st.write(f"Selected Longitude: {lon}")
+    
+    # Date and Time inputs
+    col3, col4 = st.columns(2)
+    with col3:
+        input_date = st.date_input("Select Date", datetime.now())
+    with col4:
+        input_time = st.time_input("Select Time", datetime.now().time())
+    
+    # Combine date and time
+    datetime_input = datetime.combine(input_date, input_time)
     
     # Map Visualization
     m = folium.Map(location=[lat, lon], zoom_start=10)
@@ -99,101 +179,90 @@ def main():
     folium_static(m)
 
     # Data Source Specific Sections
-    if data_source == "OpenWeather":
-        st.header("🌦️ Weather Data")
-        
-        # Fetch OpenWeather Data
-        current_data, forecast_data = fetch_openweather_data(lat, lon)
+    if data_source == "OpenWeather Historical":
+        st.header("🕰️ Historical Weather Data")
         
-        if current_data and forecast_data:
-            # Current Weather Display
-            st.subheader("Current Weather")
-            col1, col2 = st.columns(2)
+        if st.button("Retrieve Historical Weather Data"):
+            historical_data = fetch_openweather_historical_data(lat, lon, datetime_input)
             
-            with col1:
-                st.metric("Temperature", f"{current_data['main']['temp']}°C")
-                st.metric("Feels Like", f"{current_data['main']['feels_like']}°C")
-            
-            with col2:
-                st.metric("Humidity", f"{current_data['main']['humidity']}%")
-                st.metric("Wind Speed", f"{current_data['wind']['speed']} m/s")
-            
-            # Forecast Visualization
-            st.subheader("5-Day Forecast")
-            forecast_df = pd.DataFrame([
-                {
-                    'date': entry['dt_txt'],
-                    'temperature': entry['main']['temp'],
-                    'humidity': entry['main']['humidity'],
-                    'description': entry['weather'][0]['description']
-                } 
-                for entry in forecast_data['list']
-            ])
-            
-            # Temperature Forecast Plot
-            fig = px.line(
-                forecast_df, 
-                x='date', 
-                y='temperature', 
-                title='Temperature Forecast'
-            )
-            st.plotly_chart(fig)
+            if historical_data:
+                current = historical_data.get('current', {})
+                
+                st.subheader(f"Historical Weather on {datetime_input}")
+                
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    st.metric("Temperature", f"{current.get('temp', 'N/A')}°C")
+                    st.metric("Feels Like", f"{current.get('feels_like', 'N/A')}°C")
+                    st.metric("Humidity", f"{current.get('humidity', 'N/A')}%")
+                
+                with col2:
+                    st.metric("Wind Speed", f"{current.get('wind_speed', 'N/A')} m/s")
+                    st.metric("Wind Direction", f"{current.get('wind_deg', 'N/A')}°")
+                    st.metric("Pressure", f"{current.get('pressure', 'N/A')} hPa")
 
     elif data_source == "Stormglass":
-        st.header("🌊 Marine Forecast")
-        
-        # Date Range Selection
-        start_date = st.date_input("Start Date", datetime.now())
-        end_date = st.date_input("End Date", datetime.now() + timedelta(days=5))
+        st.header("🌊 Comprehensive Marine Data")
         
-        # Fetch Stormglass Data
-        marine_data = fetch_stormglass_data(lat, lon, start_date, end_date)
-        
-        if marine_data and 'hours' in marine_data:
-            # Process Marine Data
-            marine_df = pd.DataFrame([
-                {
-                    'time': hour['time'],
-                    'wave_height': hour.get('waveHeight', {}).get('icon', np.nan),
-                    'wind_speed': hour.get('windSpeed', {}).get('icon', np.nan),
-                    'water_temp': hour.get('waterTemperature', {}).get('icon', np.nan)
-                }
-                for hour in marine_data['hours']
-            ])
-            
-            # Marine Forecast Plots
-            fig_wave = px.line(marine_df, x='time', y='wave_height', title='Wave Height')
-            fig_wind = px.line(marine_df, x='time', y='wind_speed', title='Wind Speed')
+        if st.button("Retrieve Stormglass Data"):
+            stormglass_data = fetch_stormglass_comprehensive_data(lat, lon, datetime_input)
             
-            st.plotly_chart(fig_wave)
-            st.plotly_chart(fig_wind)
+            if stormglass_data and 'hours' in stormglass_data:
+                # Process and display marine data
+                marine_df = pd.DataFrame([
+                    {
+                        'time': pd.to_datetime(hour['time']),
+                        'wave_height': hour.get('waveHeight', {}).get('icon', np.nan),
+                        'wind_speed': hour.get('windSpeed', {}).get('icon', np.nan),
+                        'water_temp': hour.get('waterTemperature', {}).get('icon', np.nan),
+                        'current_speed': hour.get('currentSpeed', {}).get('icon', np.nan)
+                    }
+                    for hour in stormglass_data['hours']
+                ])
+                
+                # Plots
+                fig1 = px.line(marine_df, x='time', y='wave_height', title='Wave Height')
+                fig2 = px.line(marine_df, x='time', y='wind_speed', title='Wind Speed')
+                
+                st.plotly_chart(fig1)
+                st.plotly_chart(fig2)
 
-    elif data_source == "Air Quality":
-        st.header("💨 Air Quality Index")
-        
-        # Fetch Air Quality Data
-        air_quality_data = fetch_air_quality_data(lat, lon)
+    elif data_source == "Solunar & Tide Data":
+        st.header("🌞 Solunar & Tide Information")
         
-        if air_quality_data and 'list' in air_quality_data:
-            aq_data = air_quality_data['list'][0]['main']
-            components = air_quality_data['list'][0]['components']
-            
-            st.subheader("Air Quality Metrics")
-            col1, col2 = st.columns(2)
-            
-            with col1:
-                st.metric("AQI", aq_data['aqi'])
-                st.metric("CO", f"{components['co']} μg/m³")
-                st.metric("NO2", f"{components['no2']} μg/m³")
+        if st.button("Retrieve Solunar and Tide Data"):
+            solunar_tide_data = fetch_solunar_tide_data(lat, lon, datetime_input)
             
-            with col2:
-                st.metric("SO2", f"{components['so2']} μg/m³")
-                st.metric("PM2.5", f"{components['pm2_5']} μg/m³")
-                st.metric("PM10", f"{components['pm10']} μg/m³")
+            if solunar_tide_data:
+                # Tide Information
+                if solunar_tide_data['tide'] and 'data' in solunar_tide_data['tide']:
+                    st.subheader("Tide Times")
+                    tide_df = pd.DataFrame(solunar_tide_data['tide']['data'])
+                    
+                    for _, tide in tide_df.iterrows():
+                        st.write(f"**{tide['type'].capitalize()} Tide:**")
+                        st.write(f"Time: {pd.to_datetime(tide['time']).strftime('%Y-%m-%d %H:%M:%S')}")
+                        st.write(f"Height: {tide.get('height', 'N/A')} meters")
+                
+                # Astronomy Information
+                if solunar_tide_data['astronomy'] and 'data' in solunar_tide_data['astronomy']:
+                    st.subheader("Sun and Moon Information")
+                    astro_data = solunar_tide_data['astronomy']['data']
+                    
+                    col1, col2 = st.columns(2)
+                    
+                    with col1:
+                        st.metric("Sunrise", astro_data.get('sunrise', 'N/A'))
+                        st.metric("Solar Noon", astro_data.get('solarNoon', 'N/A'))
+                    
+                    with col2:
+                        st.metric("Sunset", astro_data.get('sunset', 'N/A'))
+                        st.metric("Day Length", astro_data.get('dayLength', 'N/A'))
 
-    elif data_source == "Marine Forecast":
-        st.header("⚓ Advanced Marine Forecast")
-        st.warning("Detailed marine forecast functionality to be implemented")
+    elif data_source == "Air Quality":
+        st.header("💨 Air Quality Index")
+        st.warning("Air Quality data functionality to be implemented")
 
 # Footer
 st.sidebar.markdown("---")
@@ -202,4 +271,6 @@ st.sidebar.markdown("Powered by Streamlit & Open APIs")
 
 # Run the main application
 if __name__ == "__main__":
-    main()
+    main()
+
+Version 3 of 3