Add February 2026 support with multi-month selection

- Add multi-month configuration via months_config.json
- Implement per-month caching for Google Sheets data
- Add month selector in dashboard UI
- Support January 2026 and February 2026 data sources
- Add Excel fallback for local development testing

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

.gitignore

@@ -2,6 +2,7 @@
 *.xlsx
 *.xls
 *.csv
+data/
 
 # Credentials (sensitive)
 credentials.json

app.py

@@ -1,6 +1,7 @@
 """
 SDR Status Tracker - FastAPI Backend
 Fetches data from Google Sheets and serves the dashboard
+Supports Excel file fallback when Google Sheet access is unavailable
 """
 import os
 import json
@@ -14,14 +15,84 @@ from google.oauth2 import service_account
 from googleapiclient.discovery import build
 from googleapiclient.errors import HttpError
 
+# Excel file support
+from excel_parser import read_excel_file, get_excel_file_path
+
 app = FastAPI(title="SDR Status Tracker")
 
-# Configuration via environment variables
+# Configuration via environment variables (fallback for backward compatibility)
 SHEET_ID = os.environ.get("GOOGLE_SHEET_ID", "1af6-2KsRqeTQxdw5KVRp2WCrM6RT7HIcl70m-GgGZB4")
 SHEET_GID = os.environ.get("GOOGLE_SHEET_GID", "1864606926")  # Tab ID (configured via env var for current month)
 
-# Cache - with webhook invalidation, we can use a long TTL
-_cache = {"data": None, "timestamp": None}
+# Month configuration file path
+MONTHS_CONFIG_FILE = "months_config.json"
+
+# Month configuration (loaded at startup)
+_months_config = {"months": [], "default_month": None, "loaded_at": None}
+
+def load_months_config(force_reload=False):
+    """
+    Load month configuration from JSON file.
+    Falls back to env var for backward compatibility if file not found.
+    """
+    global _months_config
+
+    if _months_config["months"] and not force_reload:
+        return _months_config
+
+    try:
+        with open(MONTHS_CONFIG_FILE, "r") as f:
+            config = json.load(f)
+
+        _months_config["months"] = config.get("months", [])
+        _months_config["default_month"] = config.get("default_month")
+        _months_config["loaded_at"] = datetime.now().isoformat()
+        print(f"Months config loaded from {MONTHS_CONFIG_FILE}: {len(_months_config['months'])} months")
+
+    except FileNotFoundError:
+        print(f"Months config file {MONTHS_CONFIG_FILE} not found, using env var fallback")
+        # Fallback: create single month from env var
+        _months_config["months"] = [{
+            "id": "default",
+            "label": "Current Month",
+            "sheet_id": SHEET_ID,
+            "tab_name": "DAILY - for SDR to add data🌟"
+        }]
+        _months_config["default_month"] = "default"
+        _months_config["loaded_at"] = datetime.now().isoformat()
+
+    except Exception as e:
+        print(f"Error loading months config: {e}, using env var fallback")
+        _months_config["months"] = [{
+            "id": "default",
+            "label": "Current Month",
+            "sheet_id": SHEET_ID,
+            "tab_name": "DAILY - for SDR to add data🌟"
+        }]
+        _months_config["default_month"] = "default"
+        _months_config["loaded_at"] = datetime.now().isoformat()
+
+    return _months_config
+
+
+def get_month_config(month_id: str = None):
+    """Get configuration for a specific month. Returns None if not found."""
+    config = load_months_config()
+    if not month_id:
+        month_id = config["default_month"]
+
+    for month in config["months"]:
+        if month["id"] == month_id:
+            return month
+    return None
+
+
+# Load months config at startup
+load_months_config()
+
+# Cache - per-month with webhook invalidation
+# Structure: {"2026-01": {"data": [...], "timestamp": datetime}, ...}
+_cache = {}
 CACHE_TTL = 3600  # 1 hour - webhook will invalidate on actual changes
 
 # Webhook secret for cache invalidation (optional security)
@@ -372,41 +443,114 @@ def extract_percentage(row, col):
 
 
 @app.get("/api/data")
-async def get_data():
-    """Fetch data from Google Sheets and return as JSON."""
+async def get_data(month: str = None, source: str = None):
+    """
+    Fetch data from Google Sheets or local Excel file.
+
+    Args:
+        month: Month ID (e.g., "2026-02"). Uses default if not specified.
+        source: Data source override. "file" forces local Excel file,
+                "api" forces Google Sheets API. Auto-detects if not specified.
+    """
     global _cache
 
-    # Check cache
-    now = datetime.now()
-    if _cache["data"] and _cache["timestamp"]:
-        age = (now - _cache["timestamp"]).total_seconds()
-        if age < CACHE_TTL:
-            return JSONResponse(content={"cases": _cache["data"], "cached": True})
+    # Get month configuration
+    months_config = load_months_config()
+    if not month:
+        month = months_config["default_month"]
 
-    try:
-        service = get_sheets_service()
+    month_config = get_month_config(month)
+    if not month_config:
+        raise HTTPException(status_code=400, detail=f"Unknown month: {month}")
 
-        # Fetch all data from the DAILY sheet tab
-        # Sheet name includes emoji: "DAILY - for SDR to add data🌟"
-        sheet_name = "DAILY - for SDR to add data🌟"
-        result = service.spreadsheets().values().get(
-            spreadsheetId=SHEET_ID,
-            range=f"'{sheet_name}'!A:AI"
-        ).execute()
+    # Check if month config specifies a file source
+    config_source = month_config.get("source", "api")
+    if source:
+        config_source = source  # Override with query param
 
-        values = result.get("values", [])
-        cases = parse_sheet_data(values)
+    # Check per-month cache
+    now = datetime.now()
+    cache_key = f"{month}:{config_source}"
+    if cache_key in _cache:
+        cache_entry = _cache[cache_key]
+        if cache_entry["data"] and cache_entry["timestamp"]:
+            age = (now - cache_entry["timestamp"]).total_seconds()
+            if age < CACHE_TTL:
+                return JSONResponse(content={
+                    "cases": cache_entry["data"],
+                    "cached": True,
+                    "month": month,
+                    "month_label": month_config["label"],
+                    "source": cache_entry.get("source", "api")
+                })
+
+    # Try to load data from the specified source
+    values = None
+    actual_source = None
+    error_messages = []
+
+    # If source is "file" or config specifies file, try file first
+    if config_source == "file":
+        file_path = month_config.get("file_path") or get_excel_file_path(month)
+        if file_path:
+            try:
+                tab_name = month_config.get("tab_name", "DAILY - for SDR to add data🌟")
+                values = read_excel_file(file_path, tab_name)
+                actual_source = "file"
+                print(f"Loaded {len(values)} rows from Excel file: {file_path}")
+            except Exception as e:
+                error_messages.append(f"Excel file error: {str(e)}")
+        else:
+            error_messages.append(f"No Excel file found for month {month}")
+
+    # If source is "api" or file failed, try Google Sheets API
+    if values is None and config_source != "file":
+        try:
+            service = get_sheets_service()
+            sheet_id = month_config["sheet_id"]
+            sheet_name = month_config.get("tab_name", "DAILY - for SDR to add data🌟")
+            result = service.spreadsheets().values().get(
+                spreadsheetId=sheet_id,
+                range=f"'{sheet_name}'!A:AI"
+            ).execute()
+            values = result.get("values", [])
+            actual_source = "api"
+        except HttpError as e:
+            error_messages.append(f"Google Sheets API error: {str(e)}")
+            # If API fails with permission error, try file fallback
+            if "403" in str(e) or "permission" in str(e).lower():
+                file_path = month_config.get("file_path") or get_excel_file_path(month)
+                if file_path:
+                    try:
+                        tab_name = month_config.get("tab_name", "DAILY - for SDR to add data🌟")
+                        values = read_excel_file(file_path, tab_name)
+                        actual_source = "file"
+                        print(f"API permission denied, fallback to Excel: {file_path}")
+                    except Exception as file_e:
+                        error_messages.append(f"Fallback Excel error: {str(file_e)}")
+        except Exception as e:
+            error_messages.append(f"Error: {str(e)}")
+
+    # If we still have no data, raise an error
+    if values is None:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to load data. Errors: {'; '.join(error_messages)}"
+        )
 
-        # Update cache
-        _cache["data"] = cases
-        _cache["timestamp"] = now
+    # Parse the data
+    cases = parse_sheet_data(values)
 
-        return JSONResponse(content={"cases": cases, "cached": False})
+    # Update cache
+    _cache[cache_key] = {"data": cases, "timestamp": now, "source": actual_source}
 
-    except HttpError as e:
-        raise HTTPException(status_code=500, detail=f"Google Sheets API error: {str(e)}")
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Error fetching data: {str(e)}")
+    return JSONResponse(content={
+        "cases": cases,
+        "cached": False,
+        "month": month,
+        "month_label": month_config["label"],
+        "source": actual_source
+    })
 
 
 @app.get("/api/config")
@@ -419,11 +563,26 @@ async def get_config():
     })
 
 
+@app.get("/api/months")
+async def get_months():
+    """Return list of available months for the dropdown selector."""
+    config = load_months_config()
+    return JSONResponse(content={
+        "months": [
+            {"id": m["id"], "label": m["label"]}
+            for m in config["months"]
+        ],
+        "default_month": config["default_month"]
+    })
+
+
 @app.post("/api/invalidate-cache")
-async def invalidate_cache(request: Request):
+async def invalidate_cache(request: Request, month: str = None):
     """
     Webhook endpoint to invalidate the cache when sheet data changes.
     Called by Google Apps Script onEdit trigger.
+    If month is specified, only that month's cache is cleared.
+    If month is not specified, all months' caches are cleared.
     """
     global _cache
 
@@ -433,9 +592,14 @@ async def invalidate_cache(request: Request):
         if not hmac.compare_digest(auth_header, WEBHOOK_SECRET):
             raise HTTPException(status_code=401, detail="Invalid webhook secret")
 
-    # Clear the cache
-    _cache["data"] = None
-    _cache["timestamp"] = None
+    # Clear the cache (specific month or all)
+    if month:
+        if month in _cache:
+            del _cache[month]
+        cleared = [month]
+    else:
+        cleared = list(_cache.keys())
+        _cache.clear()
 
     # Notify all connected SSE clients to refresh
     for queue in _sse_clients.copy():
@@ -447,6 +611,7 @@ async def invalidate_cache(request: Request):
     return JSONResponse(content={
         "success": True,
         "message": "Cache invalidated",
+        "months_cleared": cleared,
         "clients_notified": len(_sse_clients),
         "timestamp": datetime.now().isoformat()
     })
@@ -495,24 +660,41 @@ async def sse_events():
 
 
 @app.get("/api/cache-status")
-async def cache_status():
-    """Check current cache status."""
-    if _cache["timestamp"]:
-        age = (datetime.now() - _cache["timestamp"]).total_seconds()
-        return JSONResponse(content={
-            "cached": True,
-            "age_seconds": age,
-            "ttl_seconds": CACHE_TTL,
-            "expires_in": max(0, CACHE_TTL - age)
-        })
-    return JSONResponse(content={"cached": False})
+async def cache_status(month: str = None):
+    """Check current cache status for a specific month or all months."""
+    now = datetime.now()
+
+    if month:
+        # Check specific month
+        if month in _cache and _cache[month].get("timestamp"):
+            age = (now - _cache[month]["timestamp"]).total_seconds()
+            return JSONResponse(content={
+                "cached": True,
+                "month": month,
+                "age_seconds": age,
+                "ttl_seconds": CACHE_TTL,
+                "expires_in": max(0, CACHE_TTL - age)
+            })
+        return JSONResponse(content={"cached": False, "month": month})
+
+    # Return status for all cached months
+    status = {}
+    for m, entry in _cache.items():
+        if entry.get("timestamp"):
+            age = (now - entry["timestamp"]).total_seconds()
+            status[m] = {
+                "cached": True,
+                "age_seconds": age,
+                "expires_in": max(0, CACHE_TTL - age)
+            }
+    return JSONResponse(content={"months": status, "ttl_seconds": CACHE_TTL})
 
 
 @app.post("/api/reload-config")
 async def reload_config(request: Request):
     """
-    Reload column configuration from column_config.json.
-    Also invalidates the data cache to force a fresh fetch with new config.
+    Reload column configuration and months configuration.
+    Also invalidates all data caches to force a fresh fetch with new config.
     """
     global _cache
 
@@ -522,18 +704,20 @@ async def reload_config(request: Request):
         if not hmac.compare_digest(auth_header, WEBHOOK_SECRET):
             raise HTTPException(status_code=401, detail="Invalid webhook secret")
 
-    # Reload the column configuration
-    config = load_column_config(force_reload=True)
+    # Reload configurations
+    column_config = load_column_config(force_reload=True)
+    months_config = load_months_config(force_reload=True)
 
-    # Invalidate data cache to use new config
-    _cache["data"] = None
-    _cache["timestamp"] = None
+    # Invalidate all data caches
+    _cache.clear()
 
     return JSONResponse(content={
         "success": True,
-        "message": "Column config reloaded, cache invalidated",
-        "config_loaded_at": config["loaded_at"],
-        "weeks_count": len(config["weeks"]),
+        "message": "Configs reloaded, all caches invalidated",
+        "column_config_loaded_at": column_config["loaded_at"],
+        "months_config_loaded_at": months_config["loaded_at"],
+        "weeks_count": len(column_config["weeks"]),
+        "months_count": len(months_config["months"]),
         "timestamp": datetime.now().isoformat()
     })
 
@@ -559,13 +743,23 @@ async def get_column_config():
 
 
 @app.get("/api/debug")
-async def debug_data():
+async def debug_data(month: str = None):
     """Debug endpoint to see raw sheet data structure and parsed blocks."""
     try:
+        # Get month configuration
+        months_config = load_months_config()
+        if not month:
+            month = months_config["default_month"]
+
+        month_config = get_month_config(month)
+        if not month_config:
+            raise HTTPException(status_code=400, detail=f"Unknown month: {month}")
+
         service = get_sheets_service()
-        sheet_name = "DAILY - for SDR to add data🌟"
+        sheet_id = month_config["sheet_id"]
+        sheet_name = month_config.get("tab_name", "DAILY - for SDR to add data🌟")
         result = service.spreadsheets().values().get(
-            spreadsheetId=SHEET_ID,
+            spreadsheetId=sheet_id,
             range=f"'{sheet_name}'!A1:AI150"
         ).execute()
         values = result.get("values", [])

excel_parser.py

@@ -0,0 +1,219 @@
+#!/usr/bin/env python3
+"""
+Excel File Parser for SDR Status Tracker
+
+Reads Excel files (.xlsx) and converts them to the same row format
+that the Google Sheets API returns, enabling local file fallback
+when Google Sheet access is not available.
+
+Usage:
+    # As a module
+    from excel_parser import read_excel_file
+    rows = read_excel_file("data/Case status_ February 2026.xlsx")
+
+    # CLI for testing
+    python excel_parser.py data/Case_status_February_2026.xlsx
+"""
+import os
+import sys
+from typing import List, Optional
+from openpyxl import load_workbook
+
+
+# Default tab name to look for
+DEFAULT_TAB_NAME = "DAILY - for SDR to add data🌟"
+
+
+def read_excel_file(
+    file_path: str,
+    tab_name: str = DEFAULT_TAB_NAME,
+    max_col: str = "AI"
+) -> List[List]:
+    """
+    Read an Excel file and return rows as list of lists.
+
+    Matches the format returned by Google Sheets API:
+    - Returns list of rows, where each row is a list of cell values
+    - Empty cells are represented as empty strings ""
+    - Rows are trimmed to remove trailing empty cells (like Sheets API)
+
+    Args:
+        file_path: Path to the .xlsx file
+        tab_name: Name of the worksheet tab to read
+        max_col: Maximum column to read (e.g., "AI" = column 35)
+
+    Returns:
+        List of rows, each row is a list of cell values (strings)
+
+    Raises:
+        FileNotFoundError: If the Excel file doesn't exist
+        ValueError: If the specified tab is not found
+    """
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"Excel file not found: {file_path}")
+
+    # Load workbook (data_only=True to get calculated values, not formulas)
+    wb = load_workbook(file_path, data_only=True)
+
+    # Find the tab
+    if tab_name not in wb.sheetnames:
+        # Try partial match
+        matching_tabs = [name for name in wb.sheetnames if tab_name.lower() in name.lower()]
+        if matching_tabs:
+            tab_name = matching_tabs[0]
+            print(f"Using matching tab: {tab_name}")
+        else:
+            available_tabs = ", ".join(wb.sheetnames)
+            raise ValueError(f"Tab '{tab_name}' not found. Available tabs: {available_tabs}")
+
+    ws = wb[tab_name]
+
+    # Convert column letter to number (e.g., "AI" -> 35)
+    max_col_num = column_letter_to_number(max_col)
+
+    # Read all rows
+    rows = []
+    for row in ws.iter_rows(min_row=1, max_col=max_col_num):
+        row_values = []
+        for cell in row:
+            # Convert cell value to string (matching Google Sheets behavior)
+            if cell.value is None:
+                row_values.append("")
+            elif isinstance(cell.value, (int, float)):
+                # Handle percentages (stored as decimals in Excel)
+                if cell.number_format and '%' in cell.number_format:
+                    # Convert decimal to percentage integer (0.5 -> 50)
+                    row_values.append(str(int(cell.value * 100)))
+                else:
+                    # Keep numbers as-is
+                    if cell.value == int(cell.value):
+                        row_values.append(str(int(cell.value)))
+                    else:
+                        row_values.append(str(cell.value))
+            else:
+                row_values.append(str(cell.value))
+
+        # Trim trailing empty cells (like Sheets API does)
+        while row_values and row_values[-1] == "":
+            row_values.pop()
+
+        rows.append(row_values)
+
+    # Remove trailing empty rows
+    while rows and not any(rows[-1]):
+        rows.pop()
+
+    wb.close()
+    return rows
+
+
+def column_letter_to_number(col_letter: str) -> int:
+    """Convert column letter(s) to 1-based number. E.g., 'A'->1, 'Z'->26, 'AI'->35"""
+    result = 0
+    for char in col_letter.upper():
+        result = result * 26 + (ord(char) - ord('A') + 1)
+    return result
+
+
+def get_excel_file_path(month_id: str, data_dir: str = "data") -> Optional[str]:
+    """
+    Get the Excel file path for a given month.
+
+    Tries several naming patterns:
+    - data/Case status_ February 2026.xlsx
+    - data/Case_status_February_2026.xlsx
+    - data/2026-02.xlsx
+
+    Args:
+        month_id: Month ID in format "2026-02"
+        data_dir: Directory where Excel files are stored
+
+    Returns:
+        Path to Excel file if found, None otherwise
+    """
+    # Parse month_id to get month name and year
+    try:
+        year, month_num = month_id.split("-")
+        month_names = {
+            "01": "January", "02": "February", "03": "March",
+            "04": "April", "05": "May", "06": "June",
+            "07": "July", "08": "August", "09": "September",
+            "10": "October", "11": "November", "12": "December"
+        }
+        month_name = month_names.get(month_num, "")
+    except ValueError:
+        month_name = ""
+        year = ""
+
+    # List of patterns to try
+    patterns = [
+        f"Case status_ {month_name} {year}.xlsx",
+        f"Case_status_{month_name}_{year}.xlsx",
+        f"{month_id}.xlsx",
+        f"Case status {month_name} {year}.xlsx",
+    ]
+
+    for pattern in patterns:
+        path = os.path.join(data_dir, pattern)
+        if os.path.exists(path):
+            return path
+
+    return None
+
+
+def list_available_excel_files(data_dir: str = "data") -> List[str]:
+    """List all .xlsx files in the data directory."""
+    if not os.path.exists(data_dir):
+        return []
+
+    return [f for f in os.listdir(data_dir) if f.endswith('.xlsx')]
+
+
+def main():
+    """CLI for testing Excel parsing."""
+    if len(sys.argv) < 2:
+        print("Usage: python excel_parser.py <excel_file> [tab_name]")
+        print("\nExample: python excel_parser.py data/Case_status_February_2026.xlsx")
+
+        # List available files
+        files = list_available_excel_files()
+        if files:
+            print(f"\nAvailable Excel files in data/:")
+            for f in files:
+                print(f"  - {f}")
+        return 1
+
+    file_path = sys.argv[1]
+    tab_name = sys.argv[2] if len(sys.argv) > 2 else DEFAULT_TAB_NAME
+
+    try:
+        print(f"Reading: {file_path}")
+        print(f"Tab: {tab_name}")
+        print("-" * 50)
+
+        rows = read_excel_file(file_path, tab_name)
+
+        print(f"Total rows: {len(rows)}")
+        print(f"Header row 1: {rows[0][:10] if rows else 'empty'}...")
+        print(f"Header row 4: {rows[3][:10] if len(rows) > 3 else 'empty'}...")
+
+        # Show a few data rows
+        print("\nFirst data row (row 5):")
+        if len(rows) > 4:
+            print(f"  {rows[4][:15]}...")
+
+        # Count rows with data in column C (activity)
+        activity_rows = sum(1 for r in rows[4:] if len(r) > 2 and r[2])
+        print(f"\nRows with activity data: {activity_rows}")
+
+        return 0
+
+    except Exception as e:
+        print(f"Error: {e}")
+        import traceback
+        traceback.print_exc()
+        return 1
+
+
+if __name__ == "__main__":
+    exit(main())

months_config.json

@@ -0,0 +1,17 @@
+{
+  "months": [
+    {
+      "id": "2026-01",
+      "label": "January 2026",
+      "sheet_id": "1af6-2KsRqeTQxdw5KVRp2WCrM6RT7HIcl70m-GgGZB4",
+      "tab_name": "DAILY - for SDR to add data🌟"
+    },
+    {
+      "id": "2026-02",
+      "label": "February 2026",
+      "sheet_id": "173_4EJ6pWjyP96d1zpZ8VasffsciCSiRLOGB_CNn7aI",
+      "tab_name": "DAILY - for SDR to add data🌟"
+    }
+  ],
+  "default_month": "2026-02"
+}

requirements.txt

@@ -3,3 +3,4 @@ uvicorn[standard]==0.27.0
 google-auth==2.27.0
 google-api-python-client==2.116.0
 python-multipart==0.0.6
+openpyxl==3.1.2