Update match_organizer.py

match_organizer.py

@@ -1,178 +1,112 @@
 import streamlit as st
-from ortools.linear_solver import pywraplp
-from utils import read_teams_players
+from ortools.sat.python import cp_model
 import pandas as pd
-
-def schedule_incomplete_matches(num_slots, num_courts, slot_duration, availability):
-    # Load sample matches data
-    sample_matches_df = pd.read_csv("files/updated_sample_matches_data.csv")
+import gspread
+from oauth2client.service_account import ServiceAccountCredentials
+
+# Function to read data from Google Sheets
+
+def auth_gspread():
+    scope = [
+        'https://spreadsheets.google.com/feeds',
+        'https://www.googleapis.com/auth/spreadsheets',
+        'https://www.googleapis.com/auth/drive.file',
+        'https://www.googleapis.com/auth/drive'
+    ]
+    creds = Credentials.from_service_account_file('/content/apartmentgames-97503f144bf1.json',  scopes=scopes)
+    client = gspread.authorize(creds)
+    return client
     
-    # Define time slots and courts
-    time_slots = [f"Slot_{i}" for i in range(num_slots)]
-    courts = [f"Court_{i}" for i in range(num_courts)]
+def read_google_sheet(sheet_number):
+    client = auth_gspread()
+    spreadsheet = client.open('sample_data')  # Use your actual spreadsheet name
+    worksheet = spreadsheet.get_worksheet(sheet_number)  # Assuming you are using the first worksheet
+    data = worksheet.get_all_records()
+    return pd.DataFrame(data)
 
-    # Extract all players from the matches data
-    all_players = set()
-    for _, row in sample_matches_df.iterrows():
-        players = row['player1'].split(' & ') + row['player2'].split(' & ')
-        all_players.update(players)
-    all_players = list(all_players)
+def schedule_matches_screen():
+    df_players = read_google_sheet(1)  # Replace with your actual sheet name
+    df_matches = read_google_sheet(0)
     
-    # Initialize the Linear Programming Solver
-    solver = pywraplp.Solver.CreateSolver('GLOP')
-
-    # Decision Variables
-    x = {}
-    waiting_time = {}
-    for match_index in range(len(sample_matches_df)):
-        for slot in time_slots:
-            for court in courts:
-                x[(match_index, slot, court)] = solver.BoolVar(f'Match_{match_index}_{slot}_{court}')
-
-    for player in all_players:
-        for slot in time_slots:
-            waiting_time[(player, slot)] = solver.NumVar(0, solver.infinity(), f'Waiting_Time_{player}_{slot}')
-
-    # Objective Function
-    objective = solver.Objective()
-    for player in all_players:
-        for slot in time_slots:
-            objective.SetCoefficient(waiting_time[(player, slot)], 1)
-    objective.SetMinimization()
-
-    # Constraints
-    for match_index, match in sample_matches_df.iterrows():
-        # Each match must be scheduled exactly once
-        solver.Add(sum(x[(match_index, slot, court)] for slot in time_slots for court in courts) == 1)
-
-        # Matches can only be scheduled when all the players of the match are available
-        for slot in time_slots:
-            for court in courts:
-                if match['match_type'] == 'Singles':
-                    if availability[(match['player1'], slot)] == 0 or availability[(match['player2'], slot)] == 0:
-                        solver.Add(x[(match_index, slot, court)] == 0)
-                else:
-                    player1_team1, player2_team1 = match['player1'].split(' & ')
-                    player1_team2, player2_team2 = match['player2'].split(' & ')
-                    if (availability[(player1_team1, slot)] == 0 or
-                        availability[(player2_team1, slot)] == 0 or
-                        availability[(player1_team2, slot)] == 0 or
-                        availability[(player2_team2, slot)] == 0):
-                        solver.Add(x[(match_index, slot, court)] == 0)
-
-    # No player can be scheduled for two matches at the same time
-    for slot in time_slots:
-        for player in all_players:
-            solver.Add(sum(x[(match_index, slot, court)] for match_index, match in sample_matches_df.iterrows() for court in courts if player in match['player1'].split(' & ') or player in match['player2'].split(' & ')) <= 1)
-
-    # One game per court per slot
-    for slot in time_slots:
-        for court in courts:
-            solver.Add(sum(x[(match_index, slot, court)] for match_index in range(len(sample_matches_df))) <= 1)
-
-    # No player can have consecutive games
-    for slot_index in range(num_slots - 1):
-        for player in all_players:
-            for court in courts:
-                for match1_index, match1 in sample_matches_df.iterrows():
-                    for match2_index, match2 in sample_matches_df.iterrows():
-                        if player in match1['player1'].split(' & ') or player in match1['player2'].split(' & '):
-                            if player in match2['player1'].split(' & ') or player in match2['player2'].split(' & '):
-                                solver.Add(x[(match1_index, time_slots[slot_index], court)] + x[(match2_index, time_slots[slot_index + 1], court)] <= 1)
-
-    # Update players' waiting time
-    for player in all_players:
-        for slot_index, slot in enumerate(time_slots):
-            if slot_index > 0:
-                solver.Add(waiting_time[(player, slot)] >= waiting_time[(player, time_slots[slot_index - 1])] + slot_duration * (1 - sum(x[(match_index, slot, court)] for match_index, match in sample_matches_df.iterrows() for court in courts if player in match['player1'].split(' & ') or player in match['player2'].split(' & '))))
-            solver.Add(waiting_time[(player, slot)] >= 0 - slot_duration * sum(x[(match_index, slot, court)] for match_index, match in sample_matches_df.iterrows() for court in courts if player in match['player1'].split(' & ') or player in match['player2'].split(' & ')))
-
-    # Solve the optimization problem
-    status = solver.Solve()
-
-    if status == pywraplp.Solver.OPTIMAL:
-        # Process results
-        scheduled_matches = []
-        for match_index, match in sample_matches_df.iterrows():
-            if match['Incomplete'] == 1:  # Check if the match is marked as incomplete
-                for slot in time_slots:
-                    for court in courts:
-                        if x[(match_index, slot, court)].solution_value() > 0.5:
-                            scheduled_matches.append({
-                                "Match": match_index,
-                                "Team Match": match["team_match"],
-                                "Match Type": match["match_type"],
-                                "Players": f"{match['player1']} vs {match['player2']}",
-                                "Time Slot": slot,
-                                "Court": court
-                            })
-
-        # Convert results to DataFrame for easy display in Streamlit
-        scheduled_matches_df = pd.DataFrame(scheduled_matches)
-
-        # Output waiting times
-        waiting_times = pd.DataFrame(index=time_slots, columns=list(all_players))
-        for player in all_players:
-            for slot in time_slots:
-                waiting_times.at[slot, player] = waiting_time[(player, slot)].solution_value()
-
-        return scheduled_matches_df, waiting_times
-
-    else:
-        st.error('The problem does not have an optimal solution.')
-        return pd.DataFrame(), pd.DataFrame()
-
-def process_availability_data(players_availability_df, num_slots):
-    availability = {}
-    time_slots = [f"Slot_{i}" for i in range(num_slots)]
-
-    for _, row in players_availability_df.iterrows():
-        player = row['Player']
-        for slot in time_slots:
-            # Assuming the availability data has columns for each time slot
-            if slot in row:
-                availability[(player, slot)] = row[slot]
+    st.title('Tennis Match Scheduler')
+    
+    # UI components for input
+    num_courts = st.number_input('Number of Courts', min_value=1, value=3)
+    num_time_slots = st.number_input('Number of Time Slots', min_value=1, value=20)
+    
+    if st.button('Schedule Matches'):
+    
+        # Sample data
+        players_availability = {row['Player']: row['AvailabilityStatus'] for _, row in df_players.iterrows()}
+        
+        matches = []
+        for _, row in df_matches.iterrows():
+            # Process match data
+            match_players = row['player1'].split(' & ') + row['player2'].split(' & ')
+            is_completed = row['completed'] in ['TRUE', 'True', True]  # Adjust based on your data format
+            matches.append((match_players, row['match_type'] == 'Doubles', is_completed))
+        
+        num_courts = 3
+        num_time_slots = 20  # Example: 15-minute slots from 12:00 PM to 10:00 PM
+        
+        # Create the model
+        model = cp_model.CpModel()
+        
+        # Create variables
+        # Define the break period (number of time slots)
+        break_period = 2
+        
+        match_vars = {}
+        for match_id, match_info in enumerate(matches):
+            for time_slot in range(num_time_slots):
+                match_vars[(match_id, time_slot)] = model.NewBoolVar(f'match_{match_id}_time_{time_slot}')
+        
+        # Constraints
+        
+        # Player availability constraints
+        for time_slot in range(num_time_slots):
+            for player in set(player for match in matches for player in match[0]):
+                # Sum of all matches that include 'player' in 'time_slot' should be <= 1
+                model.Add(sum(match_vars[(match_id, time_slot)] for match_id, match in enumerate(matches) if player in match[0]) <= 1)
+        
+        # Update the model with break period constraints
+        for player in set(player for match in matches for player in match[0]):
+            for time_slot in range(num_time_slots - break_period):
+                # Sum of matches for 'player' in 'time_slot' and the next 'break_period' slots should be <= 1
+                model.Add(sum(match_vars[(match_id, t)]
+                              for t in range(time_slot, time_slot + break_period + 1)
+                              for match_id, match in enumerate(matches)
+                              if player in match[0]) <= 1)
+        
+        for match_id, (players_in_match, is_double, completed) in enumerate(matches):
+            if not completed and all(players_availability[player] == 'Available' for player in players_in_match):
+                model.Add(sum(match_vars[(match_id, time_slot)] for time_slot in range(num_time_slots)) == 1)
             else:
-                availability[(player, slot)] = 0  # Default to not available if slot is not in the data
-
-    return availability
-
-
-def schedule_matches_screen():
-    st.header("Dynamic Match Scheduling")
-
-    # Read players' availability
-    players_availability_df = read_teams_players()
-    print(players_availability_df.head())  # Show a preview of the availability data
-
-    # User Inputs for scheduling parameters
-    total_time = st.number_input("Enter the total available time (in minutes):", min_value=0, value=180)
-    num_slots = st.number_input("Enter the number of time slots:", min_value=1, value=6)
-    num_courts = st.number_input("Enter the number of courts:", min_value=1, value=3)
-    slot_duration = total_time / num_slots  # Calculate slot duration based on total time and number of slots
-
-    # Process availability data
-    availability = process_availability_data(players_availability_df, num_slots)
-    print("Availability Data:")
-    print(availability)  # Show the availability data
-
-    # Confirm scheduling
-    if st.button("Schedule Matches"):
-        st.write("Scheduling Matches...")  # Debugging print
-        # Run the optimization model
-        results, waiting_times = schedule_incomplete_matches(num_slots, num_courts, slot_duration, availability)
-
-        # Display results
-        if not results.empty:
-            st.subheader("Scheduled Matches:")
-            st.write(results)
-        else:
-            st.write("No matches scheduled. Please check the optimization model and data.")
-
-        if not waiting_times.empty:
-            st.subheader("Players' Waiting Times:")
-            st.write(waiting_times)
+                for time_slot in range(num_time_slots):
+                    model.Add(match_vars[(match_id, time_slot)] == 0)
+        
+        for time_slot in range(num_time_slots):
+            model.Add(sum(match_vars[(match_id, time_slot)] for match_id in range(len(matches))) <= num_courts)
+        
+        # Data structure to hold scheduled matches
+        scheduled_matches = []
+    
+        solver = cp_model.CpSolver()
+        status = solver.Solve(model)
+    
+        if status == cp_model.OPTIMAL or status == cp_model.FEASIBLE:
+            for match_id, (players_in_match, _, _) in enumerate(matches):
+                for time_slot in range(num_time_slots):
+                    if solver.BooleanValue(match_vars[(match_id, time_slot)]):
+                        scheduled_matches.append((time_slot, match_id, ' & '.join(players_in_match)))
+    
+        if status in [cp_model.OPTIMAL, cp_model.FEASIBLE]:
+            # Display the scheduled matches
+            for time_slot, match_id, players in scheduled_matches:
+                for court in range(1, num_courts + 1):
+                    if court not in court_assignment[time_slot]:
+                        court_assignment[time_slot].append(court)
+                        st.write(f'Time Slot: {time_slot}, Match: {match_id}, Players: {players}, Court: {court}')
+                        break
         else:
-            st.write("No waiting times data available.")
-
-
+            st.write('No solution found.')