Add all files with LFS support

components.py

@@ -116,31 +116,44 @@ def render_admin_panel():
 @timer(include_params=False)
 def render_stations_map(stations_df: pd.DataFrame) -> None:
     """Render the interactive stations map"""
+    # Calculate center coordinates and zoom level
+    center_lat = stations_df["Latitude"].mean()
+    center_lon = stations_df["Longitude"].mean()
+
+    # Calculate zoom based on coordinate spread
+    lat_range = stations_df["Latitude"].max() - stations_df["Latitude"].min()
+    lon_range = stations_df["Longitude"].max() - stations_df["Longitude"].min()
+    zoom = min(
+        11, max(8, 12 - max(lat_range, lon_range) * 5)
+    )  # Adjust multiplier as needed
+
     fig = px.scatter_mapbox(
         stations_df,
         lat="Latitude",
         lon="Longitude",
         hover_data={
             "Number": True,
-            "U_of_F": True,
             "Sector": True,
             "WBID": True,
             "Latitude": False,
             "Longitude": False,
+            "Most_Recent_Sample": True,
+            "Total_Samples": True,
         },
         hover_name="Name",
-        zoom=10,
         height=525,
         labels={
             "Number": "Station Number",
-            "U_of_F": "ID",
             "Sector": "Sector",
             "WBID": "WBID",
+            "Most_Recent_Sample": "Last Sample",
+            "Total_Samples": "Total Samples",
         },
     )
     fig.update_layout(
         mapbox_style="carto-positron",
         margin={"r": 0, "t": 0, "l": 0, "b": 0},
+        mapbox=dict(center=dict(lat=center_lat, lon=center_lon), zoom=zoom),
     )
     st.plotly_chart(fig, use_container_width=True)
 

pages.py

@@ -102,22 +102,77 @@ def home_section():
     map_col1, map_col2 = st.columns([3, 1])
     with map_col2:
         st.markdown("### Map Controls")
+        stations_df = get_stations_data()
+
+        # Get initial filter options
+        all_sectors = sorted(stations_df["Sector"].unique())
+        all_waterbodies = sorted(stations_df["WBID"].astype(str).unique())
+
+        # Initialize session state if needed
+        if "filtered_sectors" not in st.session_state:
+            st.session_state.filtered_sectors = all_sectors
+        if "filtered_waterbodies" not in st.session_state:
+            st.session_state.filtered_waterbodies = all_waterbodies
+
+        def update_waterbody_options():
+            """Update available waterbody options based on selected sectors"""
+            stations_df = get_stations_data()
+            selected_sectors = st.session_state.map_sector_filter
+            if selected_sectors:
+                st.session_state.filtered_waterbodies = sorted(
+                    stations_df[stations_df["Sector"].isin(selected_sectors)]["WBID"]
+                    .astype(str)
+                    .unique()
+                )
+            else:
+                st.session_state.filtered_waterbodies = all_waterbodies
+
+            # Clear waterbody selection if no longer valid
+            st.session_state.map_waterbody_filter = [
+                wb
+                for wb in st.session_state.map_waterbody_filter
+                if wb in st.session_state.filtered_waterbodies
+            ]
+
+        def update_sector_options():
+            """Update available sector options based on selected waterbodies"""
+            stations_df = get_stations_data()
+            selected_waterbodies = st.session_state.map_waterbody_filter
+            if selected_waterbodies:
+                st.session_state.filtered_sectors = sorted(
+                    stations_df[
+                        stations_df["WBID"].astype(str).isin(selected_waterbodies)
+                    ]["Sector"].unique()
+                )
+            else:
+                st.session_state.filtered_sectors = all_sectors
+
+            # Clear sector selection if no longer valid
+            st.session_state.map_sector_filter = [
+                s
+                for s in st.session_state.map_sector_filter
+                if s in st.session_state.filtered_sectors
+            ]
+
+        # Apply sector filter with callback
         sector_filter = st.multiselect(
             "Filter by Sector",
-            options=sorted(get_stations_data()["Sector"].unique()),
+            options=st.session_state.filtered_sectors,
             default=None,
             key="map_sector_filter",
+            on_change=update_waterbody_options,
         )
 
+        # Apply waterbody filter with callback
         waterbody_filter = st.multiselect(
             "Filter by Waterbody",
-            options=sorted(get_stations_data()["WBID"].astype(str).unique()),
+            options=st.session_state.filtered_waterbodies,
             default=None,
             key="map_waterbody_filter",
+            on_change=update_sector_options,
         )
 
         st.markdown("### Station Statistics")
-        stations_df = get_stations_data()
         if sector_filter:
             stations_df = stations_df[stations_df["Sector"].isin(sector_filter)]
         if waterbody_filter:
@@ -125,9 +180,16 @@ def home_section():
                 stations_df["WBID"].astype(str).isin(waterbody_filter)
             ]
 
-        st.metric("Active Stations", len(stations_df))
-        st.metric("Sectors", len(stations_df["Sector"].unique()))
-        st.metric("Waterbody IDs", len(stations_df["WBID"].unique()))
+        # Create two columns for station statistics
+        stat_col1, stat_col2 = st.columns(2)
+
+        with stat_col1:
+            st.metric("Active Stations", len(stations_df))
+            st.metric("Sectors", len(stations_df["Sector"].unique()))
+            st.metric("Waterbody IDs", len(stations_df["WBID"].unique()))
+
+        with stat_col2:
+            st.metric("Total Samples", int(stations_df["Total_Samples"].sum()))
 
     with map_col1:
         render_stations_map(stations_df)