Blowouts and the shape of the week

Source: commishdesk/stats/weekly.py::_week_summary

def _week_summary(target_week_rows: dict[str, Matchup]) -> WeekSummary:
    # A first-round playoff-bye row (opponent_roster_id is None) has no real
    # game this week -- its raw points must not compete for the week's
    # high/low (Epic 5's retro, S4).
    scores = [
        (roster_id, matchup.points)
        for roster_id, matchup in target_week_rows.items()
        if matchup.opponent_roster_id is not None
    ]

    # total_points / avg_team_score are the week's raw scoring, unaffected by
    # who has a real opponent -- only high/low/games use the opponent filter.
    all_points = [matchup.points for matchup in target_week_rows.values()]
    total_points = round(sum(all_points), 2)
    avg_team_score = round(total_points / len(all_points), 2) if all_points else 0.0

    high = None
    low = None
    if scores:
        best = min(scores, key=lambda kv: (-kv[1], _sort_key(kv[0])))
        worst = min(scores, key=lambda kv: (kv[1], _sort_key(kv[0])))
        high = TeamPoints(roster_id=best[0], points=best[1])
        low = TeamPoints(roster_id=worst[0], points=worst[1])

    seen_pairs: set[frozenset[str]] = set()
    games: list[tuple[str, str, float, bool]] = []  # (winner, loser, margin, is_blowout)
    for roster_id, matchup in target_week_rows.items():
        opponent_id = matchup.opponent_roster_id
        if opponent_id is None or opponent_id not in target_week_rows:
            continue
        pair = frozenset((roster_id, opponent_id))
        if pair in seen_pairs:
            continue
        seen_pairs.add(pair)

        opponent_points = target_week_rows[opponent_id].points
        if matchup.points > opponent_points:
            winner, loser = roster_id, opponent_id
        elif opponent_points > matchup.points:
            winner, loser = opponent_id, roster_id
        else:
            winner, loser = sorted((roster_id, opponent_id), key=_sort_key)
        winner_points = target_week_rows[winner].points
        loser_points = target_week_rows[loser].points
        margin = round(winner_points - loser_points, 2)
        is_blowout = winner_points != loser_points and _is_blowout(winner_points, loser_points)
        games.append((winner, loser, margin, is_blowout))

    closest = None
    biggest_blowout = None
    if games:
        closest_game = min(games, key=lambda g: (g[2], _sort_key(g[0])))
        closest = WeekMargin(roster_ids=[closest_game[0], closest_game[1]], margin=closest_game[2])
        # The widest margin is only "the week's biggest blowout" when that
        # game itself clears the blowout ratio -- a lopsided-looking score in
        # an otherwise tight week is not a blowout (Epic 5's retro, S5:
        # decided as a silent gate, not a relabeled non-blowout lead).
        # Two games can tie for the widest margin while only one is an actual
        # blowout (is_blowout depends on the winner/loser ratio, not margin
        # alone) -- prefer the blowout on a margin tie so it isn't dropped by
        # an unrelated roster-id tiebreak.
        biggest_game = min(games, key=lambda g: (-g[2], not g[3], _sort_key(g[0])))
        if biggest_game[3]:
            biggest_blowout = WeekMargin(roster_ids=[biggest_game[0], biggest_game[1]], margin=biggest_game[2])

    return WeekSummary(
        games=len(games),
        total_points=total_points,
        avg_team_score=avg_team_score,
        high=high,
        low=low,
        closest=closest,
        biggest_blowout=biggest_blowout,
        blowout_count=sum(1 for *_, is_blowout in games if is_blowout),
        blowout_threshold=BLOWOUT_RATIO,
    )

View this file on GitHub at v0.18.0