286 lines
8.6 KiB
Python
286 lines
8.6 KiB
Python
from __future__ import annotations
|
|
|
|
from collections import defaultdict
|
|
from dataclasses import dataclass, field
|
|
from datetime import datetime
|
|
from typing import Any
|
|
|
|
from storage import EventRow
|
|
|
|
PLAYER_PALETTE = [
|
|
"#f4a261",
|
|
"#2a9d8f",
|
|
"#8d99ae",
|
|
"#e76f51",
|
|
"#7c6cf2",
|
|
"#84cc16",
|
|
"#f59e0b",
|
|
"#10b981",
|
|
"#ef4444",
|
|
"#06b6d4",
|
|
"#a855f7",
|
|
"#eab308",
|
|
]
|
|
|
|
|
|
@dataclass
|
|
class SessionEntry:
|
|
session_date: str
|
|
player_name: str
|
|
buy_in_cents: int = 0
|
|
cash_out_cents: int = 0
|
|
notes: list[str] = field(default_factory=list)
|
|
|
|
@property
|
|
def net_cents(self) -> int:
|
|
return self.cash_out_cents - self.buy_in_cents
|
|
|
|
|
|
@dataclass
|
|
class SessionSummary:
|
|
session_date: str
|
|
entries: list[SessionEntry]
|
|
|
|
@property
|
|
def total_buy_in_cents(self) -> int:
|
|
return sum(entry.buy_in_cents for entry in self.entries)
|
|
|
|
@property
|
|
def total_cash_out_cents(self) -> int:
|
|
return sum(entry.cash_out_cents for entry in self.entries)
|
|
|
|
@property
|
|
def total_net_cents(self) -> int:
|
|
return sum(entry.net_cents for entry in self.entries)
|
|
|
|
|
|
@dataclass
|
|
class PlayerStats:
|
|
player_name: str
|
|
sessions_played: int
|
|
winning_sessions: int
|
|
losing_sessions: int
|
|
break_even_sessions: int
|
|
win_pct: float
|
|
avg_win_cents: int
|
|
avg_loss_cents: int
|
|
biggest_win_cents: int
|
|
biggest_loss_cents: int
|
|
total_buy_in_cents: int
|
|
total_cash_out_cents: int
|
|
total_net_cents: int
|
|
roi_pct: float
|
|
|
|
|
|
|
|
def cents_to_dollars(cents: int) -> str:
|
|
value = cents / 100
|
|
return f"${value:,.2f}"
|
|
|
|
|
|
|
|
def safe_date_label(session_date: str) -> str:
|
|
try:
|
|
return datetime.strptime(session_date, "%Y-%m-%d").strftime("%b %d, %Y")
|
|
except ValueError:
|
|
return session_date
|
|
|
|
|
|
|
|
def color_for_name(name: str, names: list[str]) -> str:
|
|
try:
|
|
index = sorted(names, key=str.casefold).index(name)
|
|
except ValueError:
|
|
index = abs(hash(name))
|
|
return PLAYER_PALETTE[index % len(PLAYER_PALETTE)]
|
|
|
|
|
|
|
|
def net_tone(value_cents: int) -> str:
|
|
if value_cents > 0:
|
|
return "#22c55e"
|
|
if value_cents < 0:
|
|
return "#ef4444"
|
|
return "#f59e0b"
|
|
|
|
|
|
|
|
def build_session_summaries(events: list[EventRow]) -> list[SessionSummary]:
|
|
grouped: dict[tuple[str, str], SessionEntry] = {}
|
|
|
|
for event in events:
|
|
key = (event["session_date"], event["player_name"])
|
|
if key not in grouped:
|
|
grouped[key] = SessionEntry(
|
|
session_date=event["session_date"],
|
|
player_name=event["player_name"],
|
|
)
|
|
|
|
entry = grouped[key]
|
|
if event["event_type"] == "buyin":
|
|
entry.buy_in_cents += event["amount_cents"]
|
|
elif event["event_type"] == "cashout":
|
|
entry.cash_out_cents += event["amount_cents"]
|
|
|
|
if event["note"]:
|
|
entry.notes.append(event["note"])
|
|
|
|
by_session: dict[str, list[SessionEntry]] = defaultdict(list)
|
|
for entry in grouped.values():
|
|
by_session[entry.session_date].append(entry)
|
|
|
|
sessions = [
|
|
SessionSummary(
|
|
session_date=session_date,
|
|
entries=sorted(entries, key=lambda entry: entry.player_name.casefold()),
|
|
)
|
|
for session_date, entries in by_session.items()
|
|
]
|
|
sessions.sort(key=lambda session: session.session_date, reverse=True)
|
|
return sessions
|
|
|
|
|
|
|
|
def build_leaderboard(sessions: list[SessionSummary]) -> list[PlayerStats]:
|
|
player_entries: dict[str, list[SessionEntry]] = defaultdict(list)
|
|
for session in sessions:
|
|
for entry in session.entries:
|
|
player_entries[entry.player_name].append(entry)
|
|
|
|
leaderboard: list[PlayerStats] = []
|
|
for player_name, entries in player_entries.items():
|
|
nets = [entry.net_cents for entry in entries]
|
|
wins = [value for value in nets if value > 0]
|
|
losses = [value for value in nets if value < 0]
|
|
total_buy_in = sum(entry.buy_in_cents for entry in entries)
|
|
total_cash_out = sum(entry.cash_out_cents for entry in entries)
|
|
total_net = total_cash_out - total_buy_in
|
|
sessions_played = len(entries)
|
|
winning_sessions = len(wins)
|
|
losing_sessions = len(losses)
|
|
break_even_sessions = sessions_played - winning_sessions - losing_sessions
|
|
win_pct = (winning_sessions / sessions_played * 100) if sessions_played else 0.0
|
|
avg_win = round(sum(wins) / len(wins)) if wins else 0
|
|
avg_loss = round(sum(abs(value) for value in losses) / len(losses)) if losses else 0
|
|
biggest_win = max(wins) if wins else 0
|
|
biggest_loss = min(losses) if losses else 0
|
|
roi_pct = (total_net / total_buy_in * 100) if total_buy_in else 0.0
|
|
|
|
leaderboard.append(
|
|
PlayerStats(
|
|
player_name=player_name,
|
|
sessions_played=sessions_played,
|
|
winning_sessions=winning_sessions,
|
|
losing_sessions=losing_sessions,
|
|
break_even_sessions=break_even_sessions,
|
|
win_pct=win_pct,
|
|
avg_win_cents=avg_win,
|
|
avg_loss_cents=avg_loss,
|
|
biggest_win_cents=biggest_win,
|
|
biggest_loss_cents=biggest_loss,
|
|
total_buy_in_cents=total_buy_in,
|
|
total_cash_out_cents=total_cash_out,
|
|
total_net_cents=total_net,
|
|
roi_pct=roi_pct,
|
|
)
|
|
)
|
|
|
|
leaderboard.sort(
|
|
key=lambda player: (player.total_net_cents, player.total_cash_out_cents),
|
|
reverse=True,
|
|
)
|
|
return leaderboard
|
|
|
|
|
|
|
|
def cumulative_profit_series(sessions: list[SessionSummary]) -> dict[str, Any]:
|
|
ordered_sessions = sorted(sessions, key=lambda session: session.session_date)
|
|
player_names = sorted(
|
|
{entry.player_name for session in ordered_sessions for entry in session.entries},
|
|
key=str.casefold,
|
|
)
|
|
|
|
labels = [safe_date_label(session.session_date) for session in ordered_sessions]
|
|
datasets = []
|
|
|
|
for player_name in player_names:
|
|
series: list[float | None] = []
|
|
running_total = 0
|
|
has_started = False
|
|
|
|
for session in ordered_sessions:
|
|
matching_entry = next(
|
|
(entry for entry in session.entries if entry.player_name == player_name),
|
|
None,
|
|
)
|
|
if matching_entry is not None:
|
|
has_started = True
|
|
running_total += matching_entry.net_cents
|
|
series.append(round(running_total / 100, 2))
|
|
elif has_started:
|
|
series.append(round(running_total / 100, 2))
|
|
else:
|
|
series.append(None)
|
|
|
|
datasets.append(
|
|
{
|
|
"label": player_name,
|
|
"data": series,
|
|
"borderColor": color_for_name(player_name, player_names),
|
|
"backgroundColor": color_for_name(player_name, player_names),
|
|
"pointRadius": 3,
|
|
"pointHoverRadius": 5,
|
|
"pointHitRadius": 10,
|
|
"borderWidth": 2.5,
|
|
"tension": 0.22,
|
|
"spanGaps": False,
|
|
}
|
|
)
|
|
|
|
return {"labels": labels, "datasets": datasets}
|
|
|
|
|
|
|
|
def player_session_series(sessions: list[SessionSummary], player_name: str) -> dict[str, Any]:
|
|
ordered_sessions = sorted(sessions, key=lambda session: session.session_date)
|
|
labels: list[str] = []
|
|
net_values: list[float] = []
|
|
cumulative_values: list[float] = []
|
|
running_total = 0
|
|
|
|
all_player_names = sorted(
|
|
{entry.player_name for session in ordered_sessions for entry in session.entries},
|
|
key=str.casefold,
|
|
)
|
|
|
|
for session in ordered_sessions:
|
|
matching_entry = next(
|
|
(entry for entry in session.entries if entry.player_name == player_name),
|
|
None,
|
|
)
|
|
if matching_entry is None:
|
|
continue
|
|
|
|
labels.append(safe_date_label(session.session_date))
|
|
net_values.append(round(matching_entry.net_cents / 100, 2))
|
|
running_total += matching_entry.net_cents
|
|
cumulative_values.append(round(running_total / 100, 2))
|
|
|
|
return {
|
|
"labels": labels,
|
|
"color": color_for_name(player_name, all_player_names),
|
|
"net_values": net_values,
|
|
"net_colors": [net_tone(round(value * 100)) for value in net_values],
|
|
"cumulative_values": cumulative_values,
|
|
}
|
|
|
|
|
|
|
|
def session_events(events: list[EventRow], session_date: str) -> list[EventRow]:
|
|
return [event for event in events if event["session_date"] == session_date]
|
|
|
|
|
|
|
|
def unique_player_names(events: list[EventRow]) -> list[str]:
|
|
return sorted({event["player_name"] for event in events}, key=str.casefold)
|