def main(args: Namespace):
load_teams(args.database)
league = league_register[get_unique_league(args)]
load_league(args.database, league)
seasons = Season.seasons(league)
if args.history:
seasons = seasons[-args.history:]
head_season = seasons[-1]
head_table = LeagueTable(head_season, args.half)
table_map = head_table.group(args.chunks)
predicates = predicate_table[args.analysis]
matrix = np.zeros(shape=(table_map.number_of_chunks(),
len(predicates.functions)),
dtype=np.int32)
for season in seasons:
table = LeagueTable(season, args.half)
table_map = table.group(args.chunks)
fill_matrix(matrix, table_map, table, predicates, args.half)
datum = pd.DataFrame(matrix)
datum.columns = [
Event.name(func, negate=False, short=True)
for func in predicates.functions
]
datum.index = create_chunk_labels(table_map)
fig, ax = plt.subplots(nrows=1,
ncols=1,
figsize=(10, 10),
constrained_layout=True)
heatmap(datum, cmap='coolwarm', linewidth=0.5, annot=True, fmt='d', ax=ax)
ax.set_ylabel('Positions')
ax.set_xlabel(args.analysis.name.capitalize())
sublists = split_into_contiguous_groups(
[season.year for season in seasons])
title = '{} {} Seasons:{}'.format(league.country, league.name,
to_string(sublists))
if args.half != Half.both:
title = '{} ({} half)'.format(title, args.half.name)
fig.suptitle(title, fontweight='bold', fontsize=14)
plt.show(block=args.block)
def create_league_table(ax,
this_season: Season,
team: Team,
team_color: Tuple[float, float, float],
other_color: Tuple[float, float, float],
venue: Venue,
half: Half):
league_table = LeagueTable(this_season, half)
display_table = []
colors = []
team_length = 1
for i, league_row in enumerate(league_table, start=1):
display_row = [league_row.TEAM.name]
if venue == Venue.home:
display_row.extend([league_row.HW + league_row.HD + league_row.HL,
league_row.HW, league_row.HD, league_row.HL, league_row.HF, league_row.HA])
wins = league_row.HW
draws = league_row.HD
elif venue == Venue.away:
display_row.extend([league_row.AW + league_row.AD + league_row.AL,
league_row.AW, league_row.AD, league_row.AL, league_row.AF, league_row.AA])
wins = league_row.AW
draws = league_row.AD
else:
display_row.extend([league_row.W + league_row.D + league_row.L,
league_row.W, league_row.D, league_row.L, league_row.F, league_row.A])
wins = league_row.W
draws = league_row.D
pts = wins * 3 + draws
display_row.append(pts)
display_table.append(display_row)
team_length = max(team_length, len(league_row.TEAM.name))
display_table.sort(key=lambda row: row[-1], reverse=True)
for display_row in display_table:
if display_row[0] == team.name:
colors.append([team_color] * len(display_row))
else:
colors.append([other_color] * len(display_row))
df = pd.DataFrame(display_table)
df.columns = ['Team', 'Played', 'W', 'D', 'L', 'F', 'A', 'PTS']
ax.table(cellText=df.values,
colLabels=df.columns,
colLoc='left',
colWidths=[0.3, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1],
cellColours=colors,
cellLoc='left',
loc='upper center')
title = 'League table'
if half:
title = '{} ({} half)'.format(title, half.name)
ax.set_title(title)
ax.axis('off')
def compute_relative_performance(args: Namespace,
league: League,
seasons: List[Season],
team_names: List[str],
positions: List[int]):
this_season = seasons[-1]
team_summaries = {}
for name in team_names:
(row,) = extract_picked_team(args.database, name, league)
team = Team.inventory[row[0]]
team_summaries[team] = compute_summary(team, [this_season], args.venue, args.half)
summaries = []
for season in seasons:
if not season.current:
table = LeagueTable(season, args.half)
teams = table.teams_by_position(positions)
for team in teams:
summary = []
summaries.append(summary)
compute_statistics(season, team, args.venue, args.half, summary)
combined_summary = []
for summary in summaries:
for week, stat in enumerate(summary):
if week >= len(combined_summary):
combined_summary.append([])
combined_summary[week].append(stat)
color = Color()
sublists = split_into_contiguous_groups(positions)
label = 'Positions: {}'.format(to_string(sublists))
label = '{} ({}-{})'.format(label, seasons[0].year, seasons[-2].year)
average_summary = compute_average(combined_summary)
data = [Datum(average_summary, label, color.next())]
for name in team_names:
(row,) = extract_picked_team(args.database, name, league)
team = Team.inventory[row[0]]
summary = team_summaries[team][this_season]
data.append(Datum(summary, team.name, color.next()))
title = 'Relative performance comparison {}-{}'.format(seasons[0].year, seasons[-2].year)
title = add_venue_and_half_to_title(title, args.venue, args.half)
display(title, data, args.block)
def compute_chunked_data(seasons: List[Season], func: Callable, negate: bool,
venue: Venue, half: Half, chunk_size: int):
chunk_to_chart = OrderedDict()
for season in seasons:
table = LeagueTable(season, half)
table_map = table.group(chunk_size)
for chunk_id in range(table_map.number_of_chunks()):
if chunk_id not in chunk_to_chart:
chart = DataUnit(Counter(),
seasons,
positions=table_map.get_rows(chunk_id))
chunk_to_chart[chunk_id] = chart
chart = chunk_to_chart[chunk_id]
for row_id in table_map.get_rows(chunk_id):
team = table[row_id].TEAM
count_events(season, team, venue, half, func, negate, chart)
return list(chunk_to_chart.values())
def show_results(league: League, season: Season, results: List[str]):
matched = []
for fixture in season.fixtures():
result = fixture.full_time()
if result:
for given_result in results:
left, right = map(int, given_result.split('-'))
if left == result.left and right == result.right:
matched.append(fixture)
else:
messages.warning_message('Ignoring {}'.format(fixture))
if matched:
table = LeagueTable(season, Half.both)
print('>' * 40, season.year, '<' * 40)
for fixture in matched:
print('{:<2} vs {:<2}: {}'.format(
table.team_position(fixture.home_team) + 1,
table.team_position(fixture.away_team) + 1, fixture))
print()
def main(args: Namespace):
load_teams(args.database)
league = league_register[get_unique_league(args)]
load_league(args.database, league)
seasons = Season.seasons(league)
if args.history:
seasons = seasons[-args.history:]
if args.relative:
team_names = get_multiple_teams(args)
table = LeagueTable(seasons[-1], args.half)
lower, upper = table.positions(Position.from_string(args.relative))
positions = [i for i in range(lower, upper)]
compute_relative_performance(args, league, seasons, team_names, positions)
elif args.position:
team_names = get_multiple_teams(args)
compute_relative_performance(args, league, seasons, team_names, args.position)
elif args.average:
team_name = get_unique_team(args)
compute_average_performance(args, league, seasons, team_name)
else:
compute_individual_performance(args, league, seasons)
def main(args: Namespace):
load_teams(args.database)
league = league_register[get_unique_league(args)]
load_league(args.database, league)
seasons = Season.seasons(league)
if not seasons:
messages.error_message("No season data found")
if args.history:
seasons = seasons[-args.history:]
if args.team:
(row, ) = extract_picked_team(args.database, args.team, league)
selected_team = Team.inventory[row[0]]
else:
selected_team = None
func = Event.get(get_unique_event(args))
if args.chunks:
data = compute_chunked_data(seasons, func, args.negate, args.venue,
args.half, args.chunks)
nrows = len(data)
if selected_team is not None:
ncols = 3
else:
ncols = 1
fig, axes = plt.subplots(nrows=len(data),
ncols=ncols,
figsize=(20, 13),
squeeze=False,
constrained_layout=True)
x_limit, _ = find_limits(data)
for i, datum in enumerate(data):
ax = axes[i, 0]
plot(ax, datum, x_limit, args.lines)
if selected_team is not None:
golden_season = seasons[-1]
golden_table = LeagueTable(golden_season, args.half)
golden_map = golden_table.group(args.chunks)
chunk_to_seasons = OrderedDict()
for chunk_id in range(golden_map.number_of_chunks()):
if chunk_id not in chunk_to_seasons:
chunk_to_seasons[chunk_id] = []
for season in seasons:
if season != golden_season:
table = LeagueTable(season, args.half)
table_map = table.group(args.chunks)
if selected_team in season.teams():
position = table.team_position(selected_team)
chunk_id = table_map.get_chunk(position)
chunk_to_seasons[chunk_id].append(season)
chunk_to_datum = OrderedDict()
for chunk_id, chunk_seasons in chunk_to_seasons.items():
if chunk_seasons:
datum = DataUnit(Counter(),
chunk_seasons,
team=selected_team,
positions=golden_map.get_rows(chunk_id))
chunk_to_datum[chunk_id] = datum
for season in seasons:
if season == golden_season:
position = golden_table.team_position(selected_team)
datum = DataUnit(Counter(), [golden_season],
team=selected_team,
positions=[position],
highlight=True)
golden_datum = datum
else:
if selected_team in season.teams():
table = LeagueTable(season, args.half)
table_map = table.group(args.chunks)
position = table.team_position(selected_team)
chunk_id = table_map.get_chunk(position)
datum = chunk_to_datum[chunk_id]
count_events(season, selected_team, args.venue, args.half,
func, args.negate, datum)
position = golden_table.team_position(selected_team)
chunk_id = golden_map.get_chunk(position)
ax = axes[chunk_id, 1]
plot(ax, golden_datum, x_limit, args.lines)
used = {(chunk_id, 1)}
for chunk_id, datum in chunk_to_datum.items():
ax = axes[chunk_id, 2]
plot(ax, datum, x_limit, args.lines)
used.add((chunk_id, 2))
for i in range(0, nrows):
for j in range(1, 3):
if (i, j) not in used:
fig.delaxes(axes[i, j])
else:
data = compute_aggregated_data(seasons, selected_team, func,
args.negate, args.venue, args.half)
x_limit, _ = find_limits(data)
display = DisplayGrid(len(data), 2)
fig, axes = plt.subplots(nrows=display.nrows,
ncols=display.ncols,
figsize=(20, 10),
squeeze=False)
for i, datum in enumerate(data):
cell_x, cell_y = display.index(i)
ax = axes[cell_x, cell_y]
plot(ax, datum, x_limit, args.lines)
title = construct_title(league, func, args.negate, args.venue, args.half)
fig.suptitle(title, fontweight='bold', fontsize=14)
plt.show(block=args.block)
def main(args: Namespace):
league = league_register[get_unique_league(args)]
load_database(args.database, league)
seasons = Season.seasons(league)
this_season = seasons.pop()
assert this_season.current
func = Event.get(get_unique_event(args))
for i in range(1, 38):
prediction = Prediction(func, i)
penalties = Counter()
for season in seasons:
table = LeagueTable(season, Half.both)
states = {team: TeamState() for team in season.teams()}
season.sort_fixtures()
fixture: Fixture
for fixture in season.fixtures():
if args.half == Half.both:
result = fixture.full_time()
elif args.half == Half.first:
result = fixture.first_half()
elif args.half == Half.second:
result = fixture.second_half()
if result:
home_result = fixture.canonicalise_result(
fixture.home_team, result)
home_outcome = prediction.func(home_result)
home_state = states[fixture.home_team]
if not home_outcome:
home_state.fixtures.append(fixture)
else:
if home_state.alive:
index = len(
home_state.fixtures) - prediction.minimum + 1
penalties[index] += 1
states[fixture.home_team] = TeamState()
if len(home_state.fixtures) == prediction.minimum:
final_position = table.team_position(fixture.home_team)
if final_position not in [
0, 1, len(table) - 2,
len(table) - 1
]:
home_state.alive = True
away_result = fixture.canonicalise_result(
fixture.away_team, result)
away_outcome = prediction.func(away_result)
away_state = states[fixture.away_team]
if not away_outcome:
away_state.fixtures.append(fixture)
else:
if away_state.alive:
index = len(
away_state.fixtures) - prediction.minimum + 1
penalties[index] += 1
states[fixture.away_team] = TeamState()
away_state.fixtures.append(fixture)
if len(away_state.fixtures) == prediction.minimum:
final_position = table.team_position(fixture.away_team)
if final_position not in [
0, 1, len(table) - 2,
len(table) - 1
]:
away_state.alive = True
total_penalty = 0
total_correct = 0
for distance, correct in penalties.items():
exponent = distance
this_penalty = 2**exponent - 1
total_penalty += this_penalty * correct
total_correct += correct
if total_penalty:
print(
'Betting from sequences of {} returns {} right with a penalty of {}'
.format(i, total_correct, total_penalty))
def main(args: Namespace):
load_teams(args.database)
league = league_register[get_unique_league(args)]
load_league(args.database, league)
seasons = Season.seasons(league)
if args.history:
seasons = seasons[-args.history:]
event = Event.get(get_unique_event(args))
head_season = seasons[-1]
head_table = LeagueTable(head_season, args.half)
if head_table.played() == 0:
head_season = seasons[-2]
head_table = LeagueTable(head_season, args.half)
nrows = 1
else:
nrows = 2
head_map = head_table.group(args.chunks)
shape = (head_map.number_of_chunks(), head_map.number_of_chunks())
historical_matrix = np.zeros(shape=shape, dtype=np.int32)
historical_seasons = seasons[:-1]
for season in historical_seasons:
table = LeagueTable(season, args.half)
fill_matrix(event, args.symmetry, historical_matrix, head_map, table,
args.half)
display = DisplayGrid(nrows, 1)
fig, axs = plt.subplots(nrows=display.nrows,
ncols=display.ncols,
figsize=(15, 12),
squeeze=False,
constrained_layout=True)
datum = pd.DataFrame(historical_matrix)
sublists = split_into_contiguous_groups(
[season.year for season in historical_seasons])
title = 'Seasons:{}'.format(to_string(sublists))
cell_x, cell_y = display.index(0)
ax = axs[cell_x, cell_y]
populate_axis(head_map, datum, ax, title)
if nrows == 2:
now_matrix = np.zeros(shape=shape, dtype=np.int32)
fill_matrix(event, args.symmetry, now_matrix, head_map, head_table,
args.half)
datum = pd.DataFrame(now_matrix)
title = 'Season:{}'.format(head_season.year)
cell_x, cell_y = display.index(1)
ax = axs[cell_x, cell_y]
populate_axis(head_map, datum, ax, title)
title = '{} {}: {}'.format(league.country, league.name,
Event.name(event, args.negate))
if args.half != Half.both:
title = '{} ({} half)'.format(title, args.half.name)
fig.suptitle(title, fontweight='bold', fontsize=14)
plt.show(block=args.block)