1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
|
from math import floor
from app import app, db
from datetime import date
from sqlalchemy import func
from typing import Tuple, Sequence
from random import shuffle, sample
from random import randint, getrandbits
from names import get_first_name, get_last_name
from app.model import Player, Court, Game, DisplayGame
def _shuffle_two_lists(a: list, b: list) -> Tuple[list, list]:
indices = list(range(len(a)))
shuffle(indices)
a = [a[index] for index in indices]
b = [b[index] for index in indices]
return a, b
def _pick_from_list_after_sorting_other(a: list, b: list[int]) -> list:
indices = [i[0] for i in sorted(enumerate(b), key=lambda x: x[1])]
return [a[index] for index in indices]
def sample_list(indices: list, cost: list[int], count=None) -> list:
if count is None:
count = len(indices)
indices, cost = _shuffle_two_lists(indices, cost)
indices = _pick_from_list_after_sorting_other(indices, cost)[:count]
return indices
def _normalize_skill(level: int, new_max: int) -> int:
scaling = (new_max - 1) / int(app.config["MAX_PLAYER_LEVEL"])
new_level = round(scaling * level) + 1
return new_level
def select_players(players: Sequence[Player], count: int) -> list[Player]:
games = db.session.query(Game).filter(func.date(Game.date) == date.today()).all()
player_identifiers = []
for game in games:
for i in range(4):
player_identifiers.append(getattr(game, f"player_{i + 1}"))
identifiers = [player.id for player in players]
play_count = [player_identifiers.count(player.id) for player in players]
ids = sample_list(identifiers, play_count, count)
selected_players = [player for player in players if player.id in ids]
return selected_players
def group_by_four(players: list[Player], new_max: int) -> list[list[Player]]:
identifiers = [player.id for player in players]
player_levels = [_normalize_skill(int(player.level), new_max) for player in players]
identifiers = sample_list(identifiers, player_levels)
court_players = []
for i in range(0, len(players), app.config["PLAYERS_PER_COURT"]):
court_ids = identifiers[i : i + app.config["PLAYERS_PER_COURT"]]
selected_players = [player for player in players if player.id in court_ids]
court_players.append(selected_players)
return court_players
def separate_teams_and_players(
players: Sequence[Player],
) -> tuple[dict[int, list[Player]], 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 get_placeholder_games(courts: list[Court], name: str) -> list[DisplayGame]:
p = db.session.query(Player).where(Player.first_name == name).first()
if p is None:
raise ValueError("Database isn't initialized.")
player_data = {"round_id": None} | {f"player_{i + 1}": p.id for i in range(4)}
games = [
DisplayGame(Game(**({"court_id": court.id} | player_data))) # type: ignore
for court in courts
]
return games
def get_team_games(
courts: list[Court], teams: dict[int, list[Player]]
) -> list[DisplayGame]:
games = []
for court, (_, players) in zip(courts, teams.items()):
players = sample(players, app.config["PLAYERS_PER_COURT"])
players.sort(key=lambda x: x.level, reverse=True)
game = Game(
None, court.id, players[0].id, players[3].id, players[1].id, players[2].id
)
games.append(DisplayGame(game))
return games
def get_shuffle_games(
courts: list[Court], players: Sequence[Player], total_levels: int
) -> list[DisplayGame]:
required_player_count = len(courts) * app.config["PLAYERS_PER_COURT"]
selected_players = select_players(players, required_player_count)
court_players = group_by_four(selected_players, total_levels)
games = []
for court, players in zip(courts, court_players):
game = Game(
None, court.id, players[0].id, players[3].id, players[1].id, players[2].id
)
games.append(DisplayGame(game))
return games
def initialize_default_players():
db.session.query(Player).delete()
for k, v in app.config["DEFAULTS"].items():
db.session.add(Player(**{"id": v, "first_name": k, "last_name": ""}))
guest_offset = 10000
for i, (k, v) in enumerate(app.config["GUESTS"].items()):
level_offset = app.config["GUEST_COUNT"] * i
for j in range(app.config["GUEST_COUNT"]):
db.session.add(
Player(
**{
"id": guest_offset + level_offset + j,
"first_name": k,
"last_name": f"{j + 1}",
"level": v,
}
)
)
db.session.commit()
def initialize_random_database():
initialize_default_players()
player_count = 80
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
args = {
"id": 3 + i,
"first_name": get_first_name(),
"last_name": get_last_name(),
"team": team,
"status": bool(getrandbits(1)),
"level": randint(
app.config["MIN_PLAYER_LEVEL"], app.config["MAX_PLAYER_LEVEL"]
),
}
db.session.add(Player(**args))
db.session.commit()
|
