Update app.py

app.py

@@ -37,12 +37,19 @@ data_source = st.sidebar.selectbox(
 openweather_historical_readings = []  
 openweather_forecast_readings = []  
 stormglass_marine_readings = []  
-solunar_tide_readings = [] 
-
+solunar_tide_readings = []
 
 # Initialize session state for historical weather data  
 if 'openweather_historical_readings' not in st.session_state:  
-    st.session_state.openweather_historical_readings = []  
+    st.session_state.openweather_historical_readings = []
+
+# Initialize session state for marine data  
+if 'stormglass_marine_readings' not in st.session_state:  
+    st.session_state.stormglass_marine_readings = []  
+
+# Initialize session state for solunar and tide data  
+if 'solunar_tide_readings' not in st.session_state:  
+    st.session_state.solunar_tide_readings = []  
 
 # --- API CALLING FUNCTIONS ---  
 def fetch_openweather_data(lat, lon, datetime_input):  
@@ -124,33 +131,42 @@ def fetch_openweather_forecast(lat, lon):
 
 def fetch_stormglass_data(lat, lng, start_datetime, end_datetime, selected_params):  
     """Fetches marine data from Stormglass API."""  
-    params_str = ','.join(selected_params)  
-    start_str = start_datetime.isoformat()  
-    end_str = end_datetime.isoformat()  
-    url = f"https://api.stormglass.io/v2/weather/point?lat={lat}&lng={lng}&params={params_str}&start={start_str}&end={end_str}"  
-    headers = {'Authorization': STORMGLASS_API_KEY}  
     try:  
+        params_str = ','.join(selected_params)  
+        start_str = start_datetime.isoformat()  
+        end_str = end_datetime.isoformat()  
+        url = f"https://api.stormglass.io/v2/weather/point?lat={lat}&lng={lng}&params={params_str}&start={start_str}&end={end_str}"  
+        headers = {'Authorization': STORMGLASS_API_KEY}  
+
         response = requests.get(url, headers=headers)  
         response.raise_for_status()  
         data = response.json()  
 
-        # Store the marine data in the global list  
         if data and 'hours' in data:  
             for hour_data in data['hours']:  
                 processed_entry = {  
-                    'timestamp': hour_data.get('time', None),  
+                    'timestamp': hour_data.get('time'),  
                     'latitude': lat,  
                     'longitude': lng,  
-                    'wave_height': hour_data.get('waveHeight', {}).get('value', None),  
-                    'wind_speed': hour_data.get('windSpeed', {}).get('value', None),  
-                    'temperature': hour_data.get('temperature', {}).get('value', None),  
-                    # Add other relevant fields  
+                    'waveHeight': hour_data.get('waveHeight', {}).get('value'),  
+                    'wavePeriod': hour_data.get('wavePeriod', {}).get('value'),  
+                    'waveDirection': hour_data.get('waveDirection', {}).get('value'),  
+                    'windSpeed': hour_data.get('windSpeed', {}).get('value'),  
+                    'windDirection': hour_data.get('windDirection', {}).get('value'),  
+                    'airTemperature': hour_data.get('airTemperature', {}).get('value'),  
+                    'waterTemperature': hour_data.get('waterTemperature', {}).get('value'),  
+                    'seaLevel': hour_data.get('seaLevel', {}).get('value'),  
+                    'humidity': hour_data.get('humidity', {}).get('value'),  
+                    'precipitation': hour_data.get('precipitation', {}).get('value'),  
+                    'visibility': hour_data.get('visibility', {}).get('value'),  
+                    'currentSpeed': hour_data.get('currentSpeed', {}).get('value'),  
+                    'currentDirection': hour_data.get('currentDirection', {}).get('value')  
                 }  
-                stormglass_marine_readings.append(processed_entry)  
+                st.session_state.stormglass_marine_readings.append(processed_entry)  
 
         return data  
     except requests.exceptions.RequestException as e:  
-        st.error(f"Error fetching Stormglass data: {e}")  
+        st.error(f"Error fetching Stormglass marine data: {e}")  
         return None  
 
 def fetch_solunar_tide_data(lat, lon, datetime_input):  
@@ -168,7 +184,7 @@ def fetch_solunar_tide_data(lat, lon, datetime_input):
 
         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  
-        # Store the solunar and tide data in the global list  
+
         if tide_data or astronomy_data:  
             processed_entry = {  
                 'date': datetime_input.date().isoformat(),  
@@ -177,17 +193,15 @@ def fetch_solunar_tide_data(lat, lon, datetime_input):
                 'tide_data': tide_data,  
                 'astronomy_data': astronomy_data  
             }  
-            solunar_tide_readings.append(processed_entry)  
-        
+            st.session_state.solunar_tide_readings.append(processed_entry)  
 
         return {  
             'tide': tide_data,  
             'astronomy': astronomy_data  
         }  
-
     except Exception as e:  
         st.error(f"Error fetching Solunar and Tide data: {e}")  
-        return None
+        return None  
 
 def save_openweather_historical_to_csv():  
     """Save historical OpenWeather data to CSV for download."""  
@@ -405,7 +419,8 @@ def main():
                                 st.write(f"Humidity: {forecast['humidity']}% | Wind: {forecast['wind_speed']} mph")  
 
     elif data_source == "Marine":  
-        st.title("Stormglass Marine & Weather Data")  
+        st.title("Stormglass Marine & Weather Data")
+        st.subheader("Detailed Marine Weather Conditions and Forecasts")
 
         col1, col2 = st.columns(2)  
 
@@ -472,54 +487,48 @@ def main():
                             selected_params  
                         )  
 
+                        # After fetching data, process and display it  
                         if stormglass_data and 'hours' in stormglass_data:  
                             st.success(f"Retrieved {len(stormglass_data['hours'])} hours of data")  
-
-                            # Process data  
+                        
+                            # Process data for display  
                             processed_data = []  
-
                             for hour_data in stormglass_data['hours']:  
                                 hour_record = {'time': hour_data['time']}  
                                 for param in selected_params:  
                                     if param in hour_data:  
-                                        # Calculate average across sources  
                                         sources = hour_data[param]  
                                         values = [v for k, v in sources.items() if v is not None]  
-
                                         if values:  
                                             hour_record[f"{param}_avg"] = sum(values) / len(values)  
-
-                                            # Also store individual sources  
                                             for source, value in sources.items():  
                                                 if value is not None:  
                                                     hour_record[f"{param}_{source}"] = value  
-
                                 processed_data.append(hour_record)  
-
+                        
                             sg_df = pd.DataFrame(processed_data)  
                             sg_df['time'] = pd.to_datetime(sg_df['time'])  
-
-                            # Show raw data  
+                        
+                            # Show raw data in an expander  
                             with st.expander("Show Raw Data"):  
                                 st.dataframe(sg_df)  
-
-                            # Create plots for each parameter  
+                        
+                            # Create interactive visualizations  
                             for param in selected_params:  
                                 avg_col = f"{param}_avg"  
-
                                 if avg_col in sg_df.columns:  
                                     param_sources = [col for col in sg_df.columns if col.startswith(f"{param}_") and col != avg_col]  
-
-                                    # Create main plot with average values  
+                        
+                                    # Main plot with average values  
                                     fig = px.line(  
                                         sg_df,  
                                         x='time',  
                                         y=avg_col,  
                                         title=f"{param} (Average)",  
-                                        labels={'time': 'Time', avg_col: param}  
+                                        labels={'time': 'Time', avg_col: param.capitalize()}  
                                     )  
-
-                                    # Add individual sources  
+                        
+                                    # Add individual sources to the plot  
                                     for source_col in param_sources:  
                                         source_name = source_col.replace(f"{param}_", "")  
                                         fig.add_scatter(  
@@ -528,109 +537,130 @@ def main():
                                             mode='lines',  
                                             name=source_name  
                                         )  
-
+                        
                                     st.plotly_chart(fig, use_container_width=True)  
-                        else:  
-                            st.error("No data available for the selected parameters")  
-
-        with col2:  
-            if 'stormglass_data' in locals() and stormglass_data and 'hours' in stormglass_data:  
-                st.subheader("Data Statistics")  
-
-                for param in selected_params:  
-                    avg_col = f"{param}_avg"  
-
-                    if avg_col in sg_df.columns:  
-                        st.write(f"**{param}**")  
-
-                        stats_col1, stats_col2 = st.columns(2)  
-
-                        with stats_col1:  
-                            st.metric("Min", f"{sg_df[avg_col].min():.2f}")  
-                            st.metric("Max", f"{sg_df[avg_col].max():.2f}")  
-
-                        with stats_col2:  
-                            st.metric("Mean", f"{sg_df[avg_col].mean():.2f}")  
-                            st.metric("Median", f"{sg_df[avg_col].median():.2f}")  
-
-                        st.markdown("---")  
-
-                # Additional visualizations  
-                if 'waveHeight_avg' in sg_df.columns and 'windSpeed_avg' in sg_df.columns:  
-                    st.subheader("Wave Height vs Wind Speed")  
-
-                    scatter_fig = px.scatter(  
-                        sg_df,  
-                        x='windSpeed_avg',  
-                        y='waveHeight_avg',  
-                        title="Correlation: Wave Height vs Wind Speed",  
-                        labels={'windSpeed_avg': 'Wind Speed', 'waveHeight_avg': 'Wave Height'}  
-                    )  
-
-                    st.plotly_chart(scatter_fig, use_container_width=True)  
-
-                # Time of day analysis if we have at least 24 hours of data  
-                if len(sg_df) >= 24:  
-                    st.subheader("Time of Day Analysis")  
-
-                    sg_df['hour'] = sg_df['time'].dt.hour  
-
-                    for param in selected_params:  
-                        avg_col = f"{param}_avg"  
-
-                        if avg_col in sg_df.columns:  
-                            hourly_avg = sg_df.groupby('hour')[avg_col].mean().reset_index()  
-
-                            hour_fig = px.line(  
-                                hourly_avg,  
-                                x='hour',  
-                                y=avg_col,  
-                                title=f"{param} by Hour of Day",  
-                                labels={'hour': 'Hour of Day', avg_col: param}  
-                            )  
-
-                            st.plotly_chart(hour_fig, use_container_width=True)  
+                        
+                            # Display statistics for each parameter  
+                            with st.expander("View Data Statistics"):  
+                                for param in selected_params:  
+                                    avg_col = f"{param}_avg"  
+                                    if avg_col in sg_df.columns:  
+                                        stats = sg_df[avg_col].describe()  
+                                        st.write(f"**Statistics for {param.capitalize()}:**")  
+                                        st.write(f"Minimum: {stats['min']:.2f}")  
+                                        st.write(f"Maximum: {stats['max']:.2f}")  
+                                        st.write(f"Mean: {stats['mean']:.2f}")  
+                                        st.write(f"Median: {stats['50%']:.2f}")  
+                                        st.write(f"Standard Deviation: {stats['std']:.2f}")  
+                                        st.markdown("---")  
+                        
+                            # Additional visualizations  
+                            if 'waveHeight_avg' in sg_df.columns and 'windSpeed_avg' in sg_df.columns:  
+                                st.subheader("Wave Height vs Wind Speed")  
+                                scatter_fig = px.scatter(  
+                                    sg_df,  
+                                    x='windSpeed_avg',  
+                                    y='waveHeight_avg',  
+                                    title="Correlation: Wave Height vs Wind Speed",  
+                                    labels={'windSpeed_avg': 'Wind Speed', 'waveHeight_avg': 'Wave Height'}  
+                                )  
+                                st.plotly_chart(scatter_fig, use_container_width=True)  
+                        
+                            # Time of day analysis if sufficient data is available  
+                            if len(sg_df) >= 24:  
+                                st.subheader("Time of Day Analysis")  
+                                sg_df['hour'] = sg_df['time'].dt.hour  
+                        
+                                for param in selected_params:  
+                                    avg_col = f"{param}_avg"  
+                                    if avg_col in sg_df.columns:  
+                                        hourly_avg = sg_df.groupby('hour')[avg_col].mean().reset_index()  
+                                        hour_fig = px.line(  
+                                            hourly_avg,  
+                                            x='hour',  
+                                            y=avg_col,  
+                                            title=f"{param.capitalize()} by Hour of Day",  
+                                            labels={'hour': 'Hour of Day', avg_col: param.capitalize()}  
+                                        )  
+                                        st.plotly_chart(hour_fig, use_container_width=True)    
 
     elif data_source == "Solunar & Tide Data":  
-        st.header("🌞 Solunar & Tide Information")  
-
-        # Location input  
+        st.header("🌞 Solunar and Tide Information")  
+        st.subheader("Detailed Solunar and Tide Conditions")  
+    
+        # Location and date/time input  
         lat = st.number_input("Latitude", value=25.7617, step=0.001, format="%.4f")  
         lon = st.number_input("Longitude", value=-80.1918, step=0.001, format="%.4f")  
-
-        # Date input  
+    
         input_date = st.date_input("Date", datetime.now())  
         input_time = st.time_input("Time", datetime.time(datetime.now()))  
         datetime_input = datetime.combine(input_date, input_time)  
-
+    
         if st.button("Retrieve Solunar and Tide Data"):  
             solunar_tide_data = fetch_solunar_tide_data(lat, lon, datetime_input)  
-
+    
             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')}")  
+                        tide_time = pd.to_datetime(tide['time'])  
+                        st.write(f"Time: {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'))  
+                        sunrise_time = pd.to_datetime(astro_data.get('sunrise'))  
+                        st.metric("Sunrise", sunrise_time.strftime('%H:%M') if sunrise_time else 'N/A')  
                         st.metric("Solar Noon", astro_data.get('solarNoon', 'N/A'))  
-
                     with col2:  
-                        st.metric("Sunset", astro_data.get('sunset', 'N/A'))  
+                        sunset_time = pd.to_datetime(astro_data.get('sunset'))  
+                        st.metric("Sunset", sunset_time.strftime('%H:%M') if sunset_time else 'N/A')  
                         st.metric("Day Length", astro_data.get('dayLength', 'N/A'))  
+    
+                # Additional astronomy details  
+                # Visualization for moon phase  
+                if 'moonPhase' in astro_data:  
+                    st.subheader("Moon Phase Visualization")  
+                    moon_phase = astro_data['moonPhase']  
+                    fig = go.Figure(go.Indicator(  
+                        mode = "gauge+number+delta",  
+                        value = moon_phase,  
+                        title = {'text': "Moon Phase"},  
+                        delta = {'reference': 0.5, 'increasing': {'color': "RebeccaPurple"}},  
+                        gauge = {  
+                            'axis': {'range': [None, 1], 'visible': False},  
+                            'bar': {'color': "lightgray"},  
+                            'bgcolor': "lightgray",  
+                            'borderwidth': 0,  
+                            'width': 0.25  
+                        }  
+                    ))  
+                    st.plotly_chart(fig, use_container_width=True)  
+                
+                # Visualization for tide levels  
+                if solunar_tide_data['tide'] and 'data' in solunar_tide_data['tide']:  
+                    st.subheader("Tide Level Visualization")  
+                    tide_df = pd.DataFrame(solunar_tide_data['tide']['data'])  
+                    tide_df['time'] = pd.to_datetime(tide_df['time'])  
+                    tide_df['height'] = pd.to_numeric(tide_df['height'], errors='coerce')  
+                
+                    tide_fig = px.line(  
+                        tide_df,  
+                        x='time',  
+                        y='height',  
+                        title="Tide Levels Over Time",  
+                        labels={'time': 'Time', 'height': 'Tide Height (m)'}  
+                    )  
+                    st.plotly_chart(tide_fig, use_container_width=True)      
 
     elif data_source == "Fish Categories Data":  
         st.header("🐟 Fish Categires Data")