Deploy from GitHub Actions

config.py

@@ -1,5 +1,5 @@
 import os
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from datetime import datetime
 
 
@@ -14,6 +14,12 @@ class AppConfig:
     DATA_FILE_PATH: str = "data/master_data_file_1990_-_2024.parquet"
     ADMIN_PASSWORD: str = ""
 
+    # Default exclusions
+    DEFAULT_EXCLUDED_SECTORS: list[str] = field(
+        default_factory=lambda: ["FWC Oyster Reef Project"]
+    )
+    DEFAULT_EXCLUDED_STATIONS: list[str] = field(default_factory=lambda: ["3.8"])
+
     @classmethod
     def from_env(cls) -> "AppConfig":
         return cls(

settings.py

@@ -147,6 +147,80 @@ with col1:
             key="dataset_reporting_month",
             on_change=on_reporting_month_change,
         )
+    st.subheader("Data Exclusions")
+    exclusion_col1, exclusion_col2 = st.columns(2)
+
+    def on_sector_exclusion_change():
+        """Callback for sector exclusion changes"""
+        if "excluded_sectors_widget" in st.session_state:
+            # Update the persistent storage with widget values
+            st.session_state.persistent_excluded_sectors = (
+                st.session_state.excluded_sectors_widget
+            )
+
+            # Reload data with new exclusions
+            st.session_state.data = st.session_state.data_manager.load_data(
+                start_date=st.session_state.get("start_date"),
+                end_date=st.session_state.get("end_date"),
+                reporting_month=st.session_state.get("reporting_month"),
+            )
+
+    def on_station_exclusion_change():
+        """Callback for station exclusion changes"""
+        if "excluded_stations_widget" in st.session_state:
+            # Update the persistent storage with widget values
+            st.session_state.persistent_excluded_stations = (
+                st.session_state.excluded_stations_widget
+            )
+
+            # Reload data with new exclusions
+            st.session_state.data = st.session_state.data_manager.load_data(
+                start_date=st.session_state.get("start_date"),
+                end_date=st.session_state.get("end_date"),
+                reporting_month=st.session_state.get("reporting_month"),
+            )
+
+    # Initialize persistent storage if not exists
+    if "persistent_excluded_sectors" not in st.session_state:
+        st.session_state.persistent_excluded_sectors = []
+    if "persistent_excluded_stations" not in st.session_state:
+        st.session_state.persistent_excluded_stations = []
+
+    # Reload data if there are any exclusions
+    if st.session_state.get("persistent_excluded_sectors") or st.session_state.get(
+        "persistent_excluded_stations"
+    ):
+        st.session_state.data = st.session_state.data_manager.load_data(
+            start_date=st.session_state.get("start_date"),
+            end_date=st.session_state.get("end_date"),
+            reporting_month=st.session_state.get("reporting_month"),
+        )
+
+    with exclusion_col1:
+        # Get complete list of sectors from data manager
+        all_sectors = st.session_state.data_manager.all_sectors
+
+        st.multiselect(
+            "Exclude Sectors",
+            options=all_sectors,
+            default=st.session_state.persistent_excluded_sectors,
+            help="Select sectors to exclude from all analyses",
+            key="excluded_sectors_widget",
+            on_change=on_sector_exclusion_change,
+        )
+
+    with exclusion_col2:
+        # Get complete list of stations from data manager
+        all_stations = st.session_state.data_manager.all_stations
+
+        st.multiselect(
+            "Exclude Stations",
+            options=all_stations,
+            default=st.session_state.persistent_excluded_stations,
+            help="Select stations to exclude from all analyses",
+            key="excluded_stations_widget",
+            on_change=on_station_exclusion_change,
+        )
 
     render_dataset_metadata(metadata, min_date, max_date)
     render_records_by_year(st.session_state.data["raw_df"], reporting_month)

utils/data_loading.py

@@ -27,7 +27,43 @@ class DataManager:
     def __init__(self, config: AppConfig):
         self.config = config
         self._data_cache = None
-        self._metadata = None
+        self._metadata: DatasetMetadata | None = None
+        self._all_sectors: list[str] | None = None
+        self._all_stations: list[str] | None = None
+        self._initialize_complete_lists()
+
+    def _initialize_complete_lists(self) -> None:
+        """Initialize complete lists of sectors and stations from raw data"""
+        try:
+            raw_df = get_raw_data(self.config.DATA_FILE_PATH)
+
+            # Handle sectors
+            sectors = raw_df["Sector"].dropna().unique().tolist()
+            self._all_sectors = sorted(sectors)
+
+            # Handle stations - convert to float first to standardize numeric format
+            stations = raw_df["Station_Number"].dropna()
+            stations = stations.astype(float).astype(str).unique().tolist()
+            self._all_stations = sorted(stations, key=lambda x: float(x))
+
+        except Exception as e:
+            st.error(f"Failed to initialize complete lists: {str(e)}")
+            self._all_sectors = []
+            self._all_stations = []
+
+    @property
+    def all_sectors(self) -> list[str]:
+        """Get complete list of all sectors in the dataset"""
+        if self._all_sectors is None:
+            self._initialize_complete_lists()
+        return self._all_sectors if self._all_sectors is not None else []
+
+    @property
+    def all_stations(self) -> list[str]:
+        """Get complete list of all stations in the dataset"""
+        if self._all_stations is None:
+            self._initialize_complete_lists()
+        return self._all_stations if self._all_stations is not None else []
 
     @property
     def metadata(self) -> DatasetMetadata | None:
@@ -69,6 +105,26 @@ class DataManager:
                 lambda x: get_reporting_year(x, reporting_month)
             )
 
+        # Apply exclusion filters if they exist in session state
+        if (
+            "persistent_excluded_sectors" in st.session_state
+            and st.session_state.persistent_excluded_sectors
+        ):
+            raw_df = raw_df[
+                ~raw_df["Sector"].isin(st.session_state.persistent_excluded_sectors)
+            ]
+
+        if (
+            "persistent_excluded_stations" in st.session_state
+            and st.session_state.persistent_excluded_stations
+        ):
+            # Convert station numbers to standardized string format for comparison
+            df_stations = raw_df["Station_Number"].astype(float).astype(str)
+            excluded_stations = [
+                str(float(s)) for s in st.session_state.persistent_excluded_stations
+            ]
+            raw_df = raw_df[~df_stations.isin(excluded_stations)]
+
         downloads = prepare_downloads(raw_df)
 
         return {
@@ -103,6 +159,14 @@ class DataManager:
             st.cache_data.clear()
 
         try:
+            # Ensure we have the latest exclusions
+            excluded_sectors = st.session_state.get("persistent_excluded_sectors", [])
+            excluded_stations = st.session_state.get("persistent_excluded_stations", [])
+
+            # Update session state with current exclusions
+            st.session_state.persistent_excluded_sectors = excluded_sectors
+            st.session_state.persistent_excluded_stations = excluded_stations
+
             return self._load_data_internal(
                 reporting_month=reporting_month
                 if reporting_month

utils/session.py

@@ -39,10 +39,42 @@ def init_session_state(config: AppConfig) -> None:
         )
         st.session_state.admin_initialized = True
 
-    # Initialize data manager
+    # Initialize exclusion settings
+    if "exclusions_initialized" not in st.session_state:
+        # Start with default exclusions from config
+        st.session_state.update(
+            {
+                "persistent_excluded_sectors": config.DEFAULT_EXCLUDED_SECTORS,
+                "persistent_excluded_stations": config.DEFAULT_EXCLUDED_STATIONS,
+                "exclusions_initialized": True,
+            }
+        )
+
+    # Initialize data manager if not already initialized
     if "data_manager" not in st.session_state:
         st.session_state.data_manager = DataManager(config)
 
+    # Ensure excluded values are valid using complete lists from data manager
+    if "data_manager" in st.session_state:
+        # Get valid options from data manager
+        valid_sectors = set(st.session_state.data_manager.all_sectors)
+        valid_stations = set(st.session_state.data_manager.all_stations)
+
+        # Filter out invalid values
+        if "persistent_excluded_sectors" in st.session_state:
+            st.session_state.persistent_excluded_sectors = [
+                sector
+                for sector in st.session_state.persistent_excluded_sectors
+                if sector in valid_sectors
+            ]
+
+        if "persistent_excluded_stations" in st.session_state:
+            st.session_state.persistent_excluded_stations = [
+                station
+                for station in st.session_state.persistent_excluded_stations
+                if station in valid_stations
+            ]
+
     # Initialize data and date-related variables
     if "data" not in st.session_state:
         metadata = st.session_state.data_manager.metadata