Instituting a cache for the contest IDs

app.py

@@ -16,6 +16,12 @@ from global_func.predict_dupes import predict_dupes
 from global_func.highlight_rows import highlight_changes, highlight_changes_winners, highlight_changes_losers
 from global_func.load_csv import load_csv
 from global_func.contest_pricing_api import fetch_contests_for_selection, fetch_pricing_for_contest
+from global_func.contest_lobby_cache import (
+    cache_has_contests,
+    get_cached_contests,
+    parse_fd_contest_id_csv,
+    save_contests_cache,
+)
 from global_func.find_csv_mismatches import find_csv_mismatches
 from global_func.trim_portfolio import trim_portfolio
 from global_func.get_portfolio_names import get_portfolio_names
@@ -1477,18 +1483,64 @@ if selected_tab == 'Data Load':
 
         upload_csv_col, csv_template_col = st.columns([3, 1])
         if pricing_source == 'Paydirt DB':
-            contest_state_key = f"{sport_var}|{type_var}"
+            contest_state_key = f"{site_var}|{sport_var}|{type_var}"
             if st.session_state.get('pricing_contest_key') != contest_state_key:
-                st.session_state['pricing_contests'] = []
-                st.session_state['selected_pricing_contest'] = None
                 st.session_state['pricing_contest_key'] = contest_state_key
-
-            if st.button("Refresh Contests", key="refresh_pricing_contests"):
-                try:
-                    st.session_state['pricing_contests'] = fetch_contests_for_selection(sport_var, type_var)
-                except Exception as e:
-                    st.error(f"Could not fetch contests: {e}")
+                cached = get_cached_contests(salaries_db, site_var, sport_var, type_var)
+                if cached is not None:
+                    st.session_state['pricing_contests'] = cached
+                else:
                     st.session_state['pricing_contests'] = []
+                st.session_state['selected_pricing_contest'] = None
+
+            if site_var == 'Draftkings':
+                force_dk_api = st.checkbox(
+                    "Fetch new contests from DraftKings (overwrite cache)",
+                    key="force_dk_contest_api",
+                    help="If unchecked, contests load from Mongo after the first successful fetch for this site/sport/type.",
+                )
+                if st.button("Refresh Contests", key="refresh_pricing_contests"):
+                    try:
+                        if force_dk_api or not cache_has_contests(salaries_db, site_var, sport_var, type_var):
+                            contests = fetch_contests_for_selection(sport_var, type_var)
+                            save_contests_cache(salaries_db, site_var, sport_var, type_var, contests)
+                            st.session_state['pricing_contests'] = contests
+                        else:
+                            st.session_state['pricing_contests'] = (
+                                get_cached_contests(salaries_db, site_var, sport_var, type_var) or []
+                            )
+                    except Exception as e:
+                        st.error(f"Could not load contests: {e}")
+                        st.session_state['pricing_contests'] = []
+            else:
+                st.caption("FanDuel contests are stored in Mongo. Upload a contest-ID CSV below, then refresh.")
+                fd_contest_csv = st.file_uploader(
+                    "FanDuel contest list CSV (contest_id column required; contest_name optional)",
+                    type=['csv'],
+                    key="fd_paydirt_contest_csv",
+                )
+                if st.button("Save FanDuel contests to database", key="save_fd_contests_paydirt"):
+                    if fd_contest_csv is None:
+                        st.warning("Choose a CSV file first.")
+                    else:
+                        try:
+                            fd_df = pd.read_csv(fd_contest_csv)
+                            fd_list = parse_fd_contest_id_csv(fd_df)
+                            if not fd_list:
+                                st.warning("No contest IDs found in the CSV.")
+                            else:
+                                save_contests_cache(salaries_db, site_var, sport_var, type_var, fd_list)
+                                st.session_state['pricing_contests'] = fd_list
+                                st.success(f"Saved {len(fd_list)} contest(s) for {sport_var} / {type_var}.")
+                        except Exception as e:
+                            st.error(f"Could not parse or save contests: {e}")
+                if st.button("Refresh Contests", key="refresh_pricing_contests_fd"):
+                    cached = get_cached_contests(salaries_db, site_var, sport_var, type_var)
+                    if cached is None:
+                        st.session_state['pricing_contests'] = []
+                        st.info("No contests in database yet for this sport/type. Upload a CSV and save.")
+                    else:
+                        st.session_state['pricing_contests'] = cached
 
             contest_options = st.session_state.get('pricing_contests', [])
             if contest_options:
@@ -1497,33 +1549,32 @@ if selected_tab == 'Data Load':
                     f"{c.get('game_type', '')} | ${int(c.get('prize_pool', 0)):,.0f}"
                     for c in contest_options
                 ]
-                contest_dropdown_options = ["None"] + contest_labels
+                if st.session_state.get("selected_pricing_contest") not in contest_labels:
+                    st.session_state["selected_pricing_contest"] = contest_labels[0]
                 selected_label = st.selectbox(
                     "Select Contest (searchable)",
-                    options=contest_dropdown_options,
+                    options=contest_labels,
                     key="selected_pricing_contest",
-                    help="Type to search contest names."
+                    help="Type to search contest names.",
                 )
-                selected_contest = None
-                if selected_label is not None and selected_label != "None":
-                    selected_idx = contest_labels.index(selected_label)
-                    selected_contest = contest_options[selected_idx]
-
-                if st.button("Load Selected Contest Pricing", key="load_selected_contest_pricing"):
-                    if selected_label is None:
-                        st.warning("Select a contest after refreshing the contest list.")
-                        st.stop()
-                    if selected_contest is None:
-                        st.warning("Select a contest before loading pricing.")
-                        st.stop()
-                    try:
-                        pricing_df = fetch_pricing_for_contest(selected_contest['contest_id'])
-                        st.session_state['csv_file'] = load_csv(pricing_df)
-                        st.session_state['pricing_loaded'] = True
-                    except Exception as e:
-                        st.error(f"Could not load contest pricing: {e}")
+                selected_idx = contest_labels.index(selected_label)
+                selected_contest = contest_options[selected_idx]
+
+                if site_var == 'Draftkings':
+                    if st.button("Load Selected Contest Pricing", key="load_selected_contest_pricing"):
+                        try:
+                            pricing_df = fetch_pricing_for_contest(selected_contest['contest_id'])
+                            st.session_state['csv_file'] = load_csv(pricing_df)
+                            st.session_state['pricing_loaded'] = True
+                        except Exception as e:
+                            st.error(f"Could not load contest pricing: {e}")
+                else:
+                    st.info("FanDuel salaries: use **User Upload** with the site pricing CSV. Contest list above is stored for reference / future use.")
             else:
-                st.info("Click 'Refresh Contests' to load contests for the selected sport/type.")
+                if site_var == 'Draftkings':
+                    st.info("Click **Refresh Contests** to load from DraftKings (first time) or from the database.")
+                else:
+                    st.info("Upload a FanDuel contest CSV and click **Save** to populate the list, then **Refresh Contests**.")
                 
             try:
                 st.session_state['csv_file']['Salary'] = st.session_state['csv_file']['Salary'].astype(str).str.replace(',', '').astype(int)
@@ -1553,6 +1604,26 @@ if selected_tab == 'Data Load':
                 st.session_state['csv_file']['Salary'] = st.session_state['csv_file']['Salary'].astype(str).str.replace(',', '').astype(int)
             except:
                 pass
+            if site_var == 'Fanduel':
+                fd_contest_csv_uu = st.file_uploader(
+                    "Optional: FanDuel contest IDs CSV (saved to Mongo for this sport/type)",
+                    type=['csv'],
+                    key='fd_user_upload_contest_csv',
+                )
+                if st.button('Save contest IDs to database', key='save_fd_contests_user_upload'):
+                    if fd_contest_csv_uu is None:
+                        st.warning('Choose a contest CSV first.')
+                    else:
+                        try:
+                            fd_df_uu = pd.read_csv(fd_contest_csv_uu)
+                            fd_list_uu = parse_fd_contest_id_csv(fd_df_uu)
+                            if not fd_list_uu:
+                                st.warning('No contest IDs found in the CSV.')
+                            else:
+                                save_contests_cache(salaries_db, site_var, sport_var, type_var, fd_list_uu)
+                                st.success(f'Saved {len(fd_list_uu)} contest(s) for {sport_var} / {type_var}.')
+                        except Exception as e:
+                            st.error(f'Could not parse or save contests: {e}')
             
         if st.session_state['pricing_loaded']:
             if type_var == 'Showdown':

global_func/contest_lobby_cache.py

@@ -0,0 +1,114 @@
+"""Persist pricing-step contest lists in Mongo (Contest_Information DB)."""
+from datetime import datetime
+from typing import List, Optional
+
+import pandas as pd
+
+COLLECTION_NAME = "DFS_PM_pricing_contest_cache"
+_INDEX_ENSURED = False
+
+
+def _collection(db):
+    return db[COLLECTION_NAME]
+
+
+def ensure_contest_cache_indexes(db) -> None:
+    global _INDEX_ENSURED
+    if _INDEX_ENSURED:
+        return
+    try:
+        _collection(db).create_index(
+            [("site", 1), ("sport", 1), ("type", 1)],
+            unique=True,
+            name="site_sport_type_unique",
+        )
+    except Exception:
+        pass
+    _INDEX_ENSURED = True
+
+
+def cache_has_contests(db, site: str, sport: str, game_type: str) -> bool:
+    ensure_contest_cache_indexes(db)
+    return (
+        _collection(db).find_one({"site": site, "sport": sport, "type": game_type}, {"_id": 1})
+        is not None
+    )
+
+
+def get_cached_contests(db, site: str, sport: str, game_type: str) -> Optional[List[dict]]:
+    """Return cached contest list, or None if no document exists."""
+    ensure_contest_cache_indexes(db)
+    doc = _collection(db).find_one({"site": site, "sport": sport, "type": game_type})
+    if doc is None:
+        return None
+    contests = doc.get("contests")
+    if contests is None:
+        return []
+    return list(contests)
+
+
+def save_contests_cache(db, site: str, sport: str, game_type: str, contests: List[dict]) -> None:
+    ensure_contest_cache_indexes(db)
+    _collection(db).update_one(
+        {"site": site, "sport": sport, "type": game_type},
+        {
+            "$set": {
+                "contests": contests,
+                "updated_at": datetime.utcnow(),
+            }
+        },
+        upsert=True,
+    )
+
+
+def parse_fd_contest_id_csv(df: pd.DataFrame) -> List[dict]:
+    """Build contest dicts for the pricing dropdown from a FanDuel-oriented upload."""
+    if df is None or df.empty:
+        return []
+
+    cols = {str(c).strip(): c for c in df.columns}
+    id_key = None
+    for label in ("contest_id", "Contest ID", "contestId", "ID", "Id", "id"):
+        if label in cols:
+            id_key = cols[label]
+            break
+    if id_key is None:
+        first = list(df.columns)[0]
+        id_key = first
+
+    name_key = None
+    for label in ("contest_name", "Contest Name", "Contest", "Name", "n", "nickname"):
+        if label in cols:
+            name_key = cols[label]
+            break
+
+    out: List[dict] = []
+    for _, row in df.iterrows():
+        raw_id = row.get(id_key)
+        if pd.isna(raw_id):
+            continue
+        s = str(raw_id).strip().replace(",", "")
+        if not s:
+            continue
+        try:
+            cid = int(float(s))
+        except (ValueError, TypeError):
+            cid = s
+        name = ""
+        if name_key is not None:
+            v = row.get(name_key)
+            if pd.notna(v):
+                name = str(v).strip()
+        if not name:
+            name = f"Contest {cid}"
+        out.append(
+            {
+                "contest_name": name,
+                "contest_id": cid,
+                "contest_date": "",
+                "contest_date_display": "",
+                "game_type": "",
+                "prize_pool": 0,
+            }
+        )
+    return out