Fixed bug with team based games

1 files changed, 33 insertions, 67 deletions

diff --git a/src/match_up/utilities.py b/src/match_up/utilities.py
index fa82b58..7140a5f 100644
--- a/src/match_up/utilities.py
+++ b/src/match_up/utilities.py
@@ -1,17 +1,7 @@
-from math import floor
 from typing import Tuple
-from random import shuffle
-from pandas import read_csv
-from random import randint, getrandbits, sample
-from names import get_first_name, get_last_name
+from random import shuffle, sample
 from match_up.data import Player, DisplayPlayer, Team, Game
-from match_up.data import (
-    MIN_LEVEL,
-    MAX_LEVEL,
-    PLAYER_PER_COURT,
-    GUESTS_PER_LEVEL,
-    GUEST_LEVELS,
-)
+from match_up.data import MAX_LEVEL, PLAYER_PER_COURT
 
 
 def _shuffle_two_lists(a: list, b: list) -> Tuple[list, list]:
@@ -71,7 +61,9 @@ def _create_groups_of_four_players(
     return court_players
 
 
-def _create_shuffle_games(courts: dict, players: list[Player], levels: int) -> list[Game]:
+def _create_shuffle_games(
+    courts: dict, players: list[Player], levels: int
+) -> list[Game]:
     court_players = _create_groups_of_four_players(players, levels)
     games = []
     for court, players in zip(courts, court_players):
@@ -84,13 +76,14 @@ def _create_shuffle_games(courts: dict, players: list[Player], levels: int) -> l
         games.append(Game(court, team1, team2))
     return games
 
+
 def _create_team_games(courts: dict, teams: dict) -> tuple[list[Game], list[Player]]:
     games = []
     selected_players = []
     for court, (_, players) in zip(courts, teams.items()):
         players = sample(players, PLAYER_PER_COURT)
-        selected_players.append(players)
-        players.sort(key=lambda x : x.level, reverse=True)
+        selected_players += players
+        players.sort(key=lambda x: x.level, reverse=True)
         team1 = Team(
             player1=DisplayPlayer(players[0]), player2=DisplayPlayer(players[3])
         )
@@ -101,57 +94,30 @@ def _create_team_games(courts: dict, teams: dict) -> tuple[list[Game], list[Play
     return games, selected_players
 
 
-def _init_guests(session) -> None:
-    for level_id, level in enumerate(GUEST_LEVELS):
-        for player_id in range(GUESTS_PER_LEVEL):
-            unique_id = (level_id * GUESTS_PER_LEVEL) + player_id + 1
-            player = Player(
-                id=-unique_id,
-                first="Guest",
-                last=str(unique_id),
-                level=level,
-                status=False,
-                count=0,
-            )
-            session.add(player)
-    session.commit()
-
-
-def _init_database_from_csv(session, csv_location: str) -> None:
-    data = read_csv(csv_location)
-    session.query(Player).delete()
-    for _, entry in data.iterrows():
-        player = Player(
-            id=entry["id"],
-            first=entry["first"],
-            last=entry["last"],
-            level=entry["skill"],
-            team=entry["team"],
-            status=False,
-            count=0,
-        )
-        session.add(player)
-    session.commit()
-    _init_guests(session)
+def separate_teams_and_players(players: list[Player]) -> Tuple[dict, list[Player]]:
+    unique_team_id = {player.team for player in players}
+    grouped_players_by_team = {team_id: [] for team_id in unique_team_id}
+    for player in players:
+        team = player.team
+        grouped_players_by_team[team].append(player)
+    active_teams = {}
+    players_without_team = []
+    for team_id in grouped_players_by_team:
+        if team_id == 0:
+            players_without_team += [
+                player for player in grouped_players_by_team[team_id]
+            ]
+        else:
+            if len(grouped_players_by_team[team_id]) >= 4:
+                active_teams[team_id] = grouped_players_by_team[team_id]
+            else:
+                players_without_team += [
+                    player for player in grouped_players_by_team[team_id]
+                ]
+    return active_teams, players_without_team
 
 
-def _init_random_database(session, player_count: int = 80) -> None:
-    total_teams = 5
-    players_per_team = 5
-    for i in range(player_count):
-        if i < total_teams * players_per_team:
-            team = floor(i / players_per_team) + 1
-        else:
-            team = 0    
-        player = Player(
-            id=i,
-            first=get_first_name(),
-            last=get_last_name(),
-            level=randint(MIN_LEVEL, MAX_LEVEL),
-            team=team,
-            status=bool(getrandbits(1)),
-            count=0,
-        )
-        session.add(player)
-    session.commit()
-    _init_guests(session)
+def split_courts(courts: dict, n) -> Tuple[dict, dict]:
+    first_half = {k: v for (k, v) in [x for x in courts.items()][:n]}
+    second_half = {k: v for (k, v) in [x for x in courts.items()][n:]}
+    return first_half, second_half