Update app.py

app.py

@@ -12,76 +12,76 @@ import random
 
 
 
-# 1. create_schedule
-def create_schedule(num_teams, num_conferences, num_inter_games):
-    full_schedule = []
-    for i in range(num_conferences):
-        conference_name = chr(65 + i)  # 'A', 'B', 'C', 'D', ...
-        combined_schedule = combine_schedules(conference_name, num_teams, num_inter_games)
-        assigned_dates = assign_dates_to_matches(combined_schedule)
-        full_schedule.extend(assigned_dates)
-    return pd.DataFrame(full_schedule, columns=["Team 1", "Team 2", "Date"])
-
-# 2. combine_schedules
-def combine_schedules(conference_name, num_teams, num_inter_games):
-    intra_conf_matches = generate_intra_conference_schedule(conference_name, num_teams)
-    inter_conf_matches = generate_inter_conference_schedule(conference_name, num_teams, num_inter_games)
-    return intra_conf_matches + inter_conf_matches
-
-# 3. generate_intra_conference_schedule
-def generate_intra_conference_schedule(conference_name, num_teams):
-    teams = [f"{conference_name}{i}" for i in range(1, num_teams + 1)]
-    matches = []
-    for i in range(len(teams)):
-        for j in range(i+1, len(teams)):
-            matches.append((teams[i], teams[j]))
-            matches.append((teams[j], teams[i]))  # Home and away
-    return matches
-
-# 4. generate_inter_conference_schedule
-def generate_inter_conference_schedule(conference_name, num_teams, num_inter_games):
-    current_conf_teams = [f"{conference_name}{i}" for i in range(1, num_teams + 1)]
-    other_confs = [chr(65 + i) for i in range(4) if chr(65 + i) != conference_name]
-    other_conf_teams = [f"{conf}{i}" for conf in other_confs for i in range(1, num_teams + 1)]
-    matches = []
-    for team in current_conf_teams:
-        opponents = random.sample(other_conf_teams, num_inter_games)
-        for opp in opponents:
-            matches.append((team, opp))
-    return matches
-
-# 5. assign_dates_to_matches
-def assign_dates_to_matches(matches):
-    start_date = date(2022, 11, 6)
-    end_date = date(2023, 3, 1)
-    available_dates = [start_date + timedelta(days=i) for i in range((end_date - start_date).days) if (start_date + timedelta(days=i)).weekday() in [0, 2, 3, 5]]
-    random.shuffle(available_dates)
+import pandas as pd
+import random
+from itertools import combinations, product
+from datetime import date, timedelta
+
+def generate_schedule_from_data(conference_team_df, available_dates):
+    # Extract unique conferences
+    conferences = conference_team_df['Conference'].unique()
+    # Ensure 'Conference' and 'Team' columns are present
+    if 'Conference' not in conference_team_df or 'Team' not in conference_team_df:
+        raise ValueError("The CSV file must contain 'Conference' and 'Team' columns.")
+    
+    # Generate intra-conference matches
+    intra_conference_matches = []
+    for conf in conferences:
+        teams_in_conf = conference_team_df[conference_team_df['Conference'] == conf]['Team'].tolist()
+        # Each team plays each other team in their conference twice
+        matches = list(combinations(teams_in_conf, 2))
+        intra_conference_matches.extend(matches)
+        intra_conference_matches.extend([(team2, team1) for team1, team2 in matches])
     
-    # Ensure cyclic reuse of dates
-    extended_dates = available_dates * (len(matches) // len(available_dates) + 1)
+    # Generate inter-conference matches (limit these to 1 per team)
+    inter_conference_matches = []
+    for team, conference in zip(conference_team_df['Team'], conference_team_df['Conference']):
+        other_conferences = [conf for conf in conferences if conf != conference]
+        other_teams = conference_team_df[conference_team_df['Conference'].isin(other_conferences)]['Team'].tolist()
+        matches = random.sample([(team, other_team) for other_team in other_teams], 1)
+        inter_conference_matches.extend(matches)
     
-    return [(match[0], match[1], extended_dates[i]) for i, match in enumerate(matches)]
+    # Combine the matches
+    combined_schedule = intra_conference_matches + inter_conference_matches
+    scheduled_matches = assign_dates_to_matches(combined_schedule, available_dates)
+
+        
+    # Convert to DataFrame
+    schedule_df = pd.DataFrame(scheduled_matches, columns=['Team 1', 'Team 2', 'Date'])
+    schedule_df['Conference 1'] = schedule_df['Team 1'].map(conference_team_df.set_index('Team').to_dict()['Conference'])
+    schedule_df['Conference 2'] = schedule_df['Team 2'].map(conference_team_df.set_index('Team').to_dict()['Conference'])
+    return schedule_df
+
+# To use this function, load your data into a DataFrame and call this function:
+# df = pd.read_csv('path/to/your/csv')
+# schedule_df = generate_schedule_from_data(df)
 
 
 # 6. generate_mock_historical_data
-def generate_mock_historical_data(num_teams, num_conferences, num_inter_games, start_date, end_date):
-    full_schedule = []
-    for i in range(num_conferences):
-        conference_name = chr(65 + i)
-        combined_schedule = combine_schedules(conference_name, num_teams, num_inter_games)
-        shuffled_dates = assign_dates_to_matches(combined_schedule)
-        random.shuffle(shuffled_dates)
-        for match in shuffled_dates:
-            full_schedule.append({
-                "Team 1": match[0],
-                "Team 2": match[1],
-                "Date": match[2]
-            })
-    return pd.DataFrame(full_schedule)
+def generate_mock_historical_data(schedule_df):
+    # Generate random scores for each team in each game
+    schedule_df['Score 1'] = [random.randint(50, 100) for _ in range(len(schedule_df))]
+    schedule_df['Score 2'] = [random.randint(50, 100) for _ in range(len(schedule_df))]
+
+    # Assume the historical data is from the previous year
+    schedule_df['Date'] = schedule_df['Date'] - pd.DateOffset(years=1)
+
+    return schedule_df
+
+# To use this function, pass the generated schedule DataFrame:
+# historical_data = generate_mock_historical_data(schedule_df)
 
+# Assign dates to matches
+def generate_available_dates(start_date, num_days=300):
+    available_dates = [start_date + timedelta(days=i) for i in range(num_days) if (start_date + timedelta(days=i)).weekday() in [0, 2, 3, 5]]
+    return available_dates
+
+def assign_dates_to_matches(matches, available_dates):
+    num_dates = len(available_dates)
+    return [(match[0], match[1], available_dates[i % num_dates]) for i, match in enumerate(matches)]
 
 # Team Workload Analysis
-def team_workload_analysis(schedule_df):
+def team_workload_analysis(schedule_df, conference_team_df):
     # Check if the DataFrame is None
     if schedule_df is None:
         plt.figure(figsize=(10, 6))
@@ -92,6 +92,7 @@ def team_workload_analysis(schedule_df):
         plt.tight_layout()
         plt.show()
         return
+    
     """Generate a bar chart showing the number of matches each team has per week."""
     schedule_df['Week'] = schedule_df['Date'].dt.isocalendar().week
     team_counts = schedule_df.groupby(['Week', 'Team 1']).size().unstack().fillna(0)
@@ -105,8 +106,9 @@ def team_workload_analysis(schedule_df):
     plt.legend(title='Teams', bbox_to_anchor=(1.05, 1), loc='upper left')
     plt.show()
 
+
 # Match Distribution
-def match_distribution(schedule_df):
+def match_distribution(schedule_df, conference_team_df):
     # Check if the DataFrame is None
     if schedule_df is None:
         plt.figure(figsize=(10, 6))
@@ -117,6 +119,7 @@ def match_distribution(schedule_df):
         plt.tight_layout()
         plt.show()
         return
+    
     """Generate a histogram showing match distribution across months."""
     schedule_df['Month'] = schedule_df['Date'].dt.month_name()
     month_order = ['November', 'December', 'January', 'February', 'March']
@@ -130,8 +133,9 @@ def match_distribution(schedule_df):
     plt.tight_layout()
     plt.show()
 
+
 # Inter-Conference Match Analysis
-def inter_conference_analysis(schedule_df):
+def inter_conference_analysis(schedule_df, conference_team_df):
     # Check if the DataFrame is None
     if schedule_df is None:
         plt.figure(figsize=(10, 6))
@@ -143,18 +147,19 @@ def inter_conference_analysis(schedule_df):
         plt.show()
         return
     """Generate a heatmap showing inter-conference match frequencies."""
-    # Extract the conference from the team names
-    schedule_df['Conference 1'] = schedule_df['Team 1'].str[0]
-    schedule_df['Conference 2'] = schedule_df['Team 2'].str[0]
+    # Map team names to their conferences
+    team_to_conference = dict(zip(conference_team_df['Team'], conference_team_df['Conference']))
+    schedule_df['Conference 1'] = schedule_df['Team 1'].map(team_to_conference)
+    schedule_df['Conference 2'] = schedule_df['Team 2'].map(team_to_conference)
     
     # Filter out intra-conference matches
-    inter_conference_df = schedule_df[schedule_df['Conference 1'] != schedule_df['Conference 2']]
+    inter_conference_df = st.session_state.schedule_df[st.session_state.schedule_df['Conference 1'] != st.session_state.schedule_df['Conference 2']]
     
     # Create a crosstab for the heatmap
     heatmap_data = pd.crosstab(inter_conference_df['Conference 1'], inter_conference_df['Conference 2'])
     
     # Ensure every conference combination has a value
-    all_conferences = schedule_df['Conference 1'].unique()
+    all_conferences = st.session_state.schedule_df['Conference 1'].unique()
     for conf in all_conferences:
         if conf not in heatmap_data.columns:
             heatmap_data[conf] = 0
@@ -172,7 +177,7 @@ def inter_conference_analysis(schedule_df):
     plt.show()
 
 # Commissioner Analytics
-def commissioner_analytics(schedule_df, commissioners):
+def commissioner_analytics(schedule_df, conference_team_df, commissioners):
     # Check if the DataFrame is None
     if schedule_df is None:
         plt.figure(figsize=(10, 6))
@@ -183,9 +188,10 @@ def commissioner_analytics(schedule_df, commissioners):
         plt.tight_layout()
         plt.show()
         return
+    
     """Generate a bar chart showing matches overseen by each commissioner."""
     # Assuming each commissioner oversees a specific conference
-    comm_dict = {f"Conference {chr(65+i)}": comm for i, comm in enumerate(commissioners)}
+    comm_dict = {conf: comm for conf, comm in zip(conference_team_df['Conference'].unique(), commissioners)}
     schedule_df['Commissioner'] = schedule_df['Conference 1'].map(comm_dict)
     
     # Count matches overseen by each commissioner
@@ -203,16 +209,35 @@ def commissioner_analytics(schedule_df, commissioners):
 
 
 
+
 # Streamlit App
 
 st.title("Basketball Game Schedule Generator")
 
-if 'num_teams' not in st.session_state:
-    st.session_state.num_teams = 10
-if 'num_conferences' not in st.session_state:
-    st.session_state.num_conferences = 4
-if 'num_inter_games' not in st.session_state:
-    st.session_state.num_inter_games = 3
+st.set_option('deprecation.showPyplotGlobalUse', False)
+
+# UI for CSV File Uploader
+uploaded_file = st.file_uploader("Choose a CSV file", type=['csv'])
+
+# Load the Uploaded CSV File
+if uploaded_file is not None:
+    df = pd.read_csv(uploaded_file)
+    st.write('Uploaded CSV file:')
+    st.write(df)
+
+    # Generate available dates here
+    start_date = date(2022, 11, 6)
+    available_dates = generate_available_dates(start_date)
+
+   # Generate Schedule using Uploaded Data
+if st.button("Generate Schedule"):
+    if uploaded_file is not None:
+        st.session_state.schedule_df = generate_schedule_from_data(df, available_dates)  # pass available_dates as argument
+        st.write('Generated Schedule:')
+        st.write(st.session_state.schedule_df)
+    else:
+        st.warning("Please upload a CSV file to proceed.")
+
 
 # Initialize session state for schedule_df and st.session_state.historical_data
 if 'schedule_df' not in st.session_state:
@@ -221,19 +246,22 @@ if 'schedule_df' not in st.session_state:
 if 'st.session_state.historical_data' not in st.session_state:
     st.session_state.historical_data = None
 
-if st.session_state.historical_data is None:
-    st.session_state.historical_data = generate_mock_historical_data(st.session_state.num_teams, st.session_state.num_conferences, st.session_state.num_inter_games, date(2022, 11, 6), date(2023, 3, 1))
-    st.session_state.historical_data['Date'] = pd.to_datetime(st.session_state.historical_data['Date'])
-
+if st.button("Generate Mock Historical Data"):
+    # Only generate historical data if it hasn’t been generated already
+    if st.session_state.historical_data is None:
+        # Ensure that the schedule has been generated before generating historical data
+        if st.session_state.schedule_df is not None:
+            # Generate the mock historical data based on the generated schedule
+            st.session_state.historical_data = generate_mock_historical_data(st.session_state.schedule_df)
+            st.write('Generated Mock Historical Data:')
+            st.write(st.session_state.historical_data)
+        else:
+            st.warning("Please generate the schedule first before generating mock historical data.")
 
     
 # Configuration UI
 st.header("Configuration")
 
-st.session_state.num_teams = st.number_input("Number of teams per conference:", min_value=2, value=st.session_state.num_teams)
-st.session_state.num_conferences = st.number_input("Number of conferences:", min_value=2, value=st.session_state.num_conferences)
-st.session_state.num_inter_games = st.number_input("Number of inter-conference games per team:", min_value=1, value=st.session_state.num_inter_games)
-
 
 commissioners = st.multiselect("Add commissioners:", options=[], default=[])
 
@@ -241,51 +269,62 @@ add_commissioner = st.text_input("New commissioner name:")
 if add_commissioner:
     commissioners.append(add_commissioner)
 
-# Schedule Generation
-if st.button("Generate Schedule"):
-    st.session_state.schedule_df = create_schedule(st.session_state.num_teams, st.session_state.num_conferences, st.session_state.num_inter_games)
-    if st.session_state.schedule_df is not None:
-        st.session_state.schedule_df['Date'] = pd.to_datetime(st.session_state.schedule_df['Date'])
 
 
 # Schedule Viewing
 st.header("View Schedule")
-conference_selector = st.selectbox("Select conference to view schedule:", options=["All"] + [f"Conference {chr(65+i)}" for i in range(st.session_state.num_conferences)])
+
 if st.session_state.schedule_df is not None:
+    # Fetching the unique conferences from the schedule DataFrame
+    conferences = st.session_state.schedule_df['Conference 1'].unique()
+    conference_selector = st.selectbox("Select conference to view schedule:", options=["All"] + list(conferences))
+
     if conference_selector == "All":
         st.dataframe(st.session_state.schedule_df)
     else:
-        filtered_schedule = st.session_state.schedule_df[(st.session_state.schedule_df["Team 1"].str.startswith(conference_selector)) | (st.session_state.schedule_df["Team 2"].str.startswith(conference_selector))]
+        # Filtering the schedule based on the selected conference
+        filtered_schedule = st.session_state.schedule_df[(st.session_state.schedule_df["Conference 1"] == conference_selector) | (st.session_state.schedule_df["Conference 2"] == conference_selector)]
         st.dataframe(filtered_schedule)
+else:
+    st.warning("Schedule has not been generated yet.")
+
 
 # Analytics & Comparisons
 st.header("Analytics & Comparisons")
 analytics_option = st.selectbox("Choose an analysis type:", ["Team Workload Analysis", "Match Distribution", "Inter-Conference Match Analysis", "Commissioner Analytics"])
-st.session_state.historical_data['Date'] = pd.to_datetime(st.session_state.historical_data['Date'])
+if st.session_state.historical_data is not None:
+    st.session_state.historical_data['Date'] = pd.to_datetime(st.session_state.historical_data['Date'])
+else:
+    st.error("Historical data has not been generated yet.")
+
 
 if analytics_option == "Team Workload Analysis":
     st.subheader("Historical Data")
-    st.pyplot(team_workload_analysis(st.session_state.historical_data))
+    st.pyplot(team_workload_analysis(st.session_state.historical_data, df))
     st.subheader("Current Data")
-    st.pyplot(team_workload_analysis(st.session_state.schedule_df))
+    st.pyplot(team_workload_analysis(st.session_state.schedule_df, df))
+
 
 elif analytics_option == "Match Distribution":
     st.subheader("Historical Data")
-    st.pyplot(match_distribution(st.session_state.historical_data))
+    st.pyplot(match_distribution(st.session_state.historical_data, df))
     st.subheader("Current Data")
-    st.pyplot(match_distribution(st.session_state.schedule_df))
+    st.pyplot(match_distribution(st.session_state.schedule_df, df))
+
 
 elif analytics_option == "Inter-Conference Match Analysis":
     st.subheader("Historical Data")
-    st.pyplot(inter_conference_analysis(st.session_state.historical_data))
+    st.pyplot(inter_conference_analysis(st.session_state.historical_data, df))
     st.subheader("Current Data")
-    st.pyplot(inter_conference_analysis(st.session_state.schedule_df))
+    st.pyplot(inter_conference_analysis(st.session_state.schedule_df, df))
+
 
 elif analytics_option == "Commissioner Analytics":
     st.subheader("Historical Data")
-    st.pyplot(commissioner_analytics(st.session_state.historical_data, commissioners))
+    st.pyplot(commissioner_analytics(st.session_state.historical_data, df, commissioners))
     st.subheader("Current Data")
-    st.pyplot(commissioner_analytics(st.session_state.schedule_df, commissioners))
+    st.pyplot(commissioner_analytics(st.session_state.schedule_df, df, commissioners))
+
 else:
     st.warning("Please generate the schedule first before viewing analytics.")