Power rank and nudge

Source: commishdesk/stats/power.py::compute_power_ranks

def compute_power_ranks(week: WeekModel, *, through_week: int | None = None) -> PowerRanks:
    """Score and rank every roster through ``through_week``.

    ``through_week`` is clamped to ``1..cutoff`` (``cutoff`` is
    ``stats/weekly.py``'s own ``_all_play_cutoff``); ``None`` means the whole
    regular season folded so far. Pure, deterministic, offline: two calls on
    equal inputs return an equal ``model_dump()``. Never raises."""
    cutoff = max(_all_play_cutoff(week), 0)
    if through_week is None or cutoff < MEANINGFUL_FROM_WEEK:
        effective = cutoff
    else:
        effective = min(max(through_week, 1), cutoff)

    roster_ids = sorted((roster.roster_id for roster in week.rosters), key=_sort_key)

    if effective < MEANINGFUL_FROM_WEEK:
        return PowerRanks(week=effective, teams=[_unranked(roster_id) for roster_id in roster_ids])

    # Reuse the weekly module's own all-play fold rather than reimplementing it:
    # a copy scoped to ``effective`` with no playoff_week_start makes
    # ``_all_play_cutoff`` return exactly ``effective``.
    scoped = week.model_copy(update={"week": effective, "playoff_week_start": None})
    weekly = compute_weekly_stats(scoped)
    records = regular_season_records(week, effective)

    components: dict[str, tuple[float, float, float]] = {}
    points_for: dict[str, float] = {}
    for team_stats in weekly.teams:
        roster_id = team_stats.roster_id
        record = records.get(roster_id)
        if record is None or not record.week_points:
            continue
        all_play = team_stats.all_play
        decisive = (all_play.wins + all_play.losses) if all_play is not None else 0
        all_play_pct = (all_play.wins / decisive) if all_play is not None and decisive else 0.0
        games = record.wins + record.losses + record.ties
        win_pct = ((record.wins + 0.5 * record.ties) / games) if games else 0.0
        components[roster_id] = (all_play_pct, win_pct, record.points_for / effective)
        points_for[roster_id] = record.points_for

    averages = [avg_pf for _, _, avg_pf in components.values()]
    low = min(averages) if averages else 0.0
    high = max(averages) if averages else 0.0

    scored: list[tuple[str, float]] = []
    for roster_id, (all_play_pct, win_pct, avg_pf) in components.items():
        normalized = (avg_pf - low) / (high - low) if high > low else 0.0
        score = (
            POWER_WEIGHTS["all_play_pct"] * all_play_pct
            + POWER_WEIGHTS["normalized_avg_pf"] * normalized
            + POWER_WEIGHTS["win_pct"] * win_pct
        )
        scored.append((roster_id, score))

    # Rank on the unrounded score; break an exact tie by points-for, then id.
    scored.sort(key=lambda item: (-item[1], -points_for[item[0]], _sort_key(item[0])))
    rank_of = {roster_id: index + 1 for index, (roster_id, _) in enumerate(scored)}
    score_of = dict(scored)

    teams: list[TeamPower] = []
    for roster_id in roster_ids:
        if roster_id not in rank_of:
            teams.append(_unranked(roster_id))
            continue
        all_play_pct, win_pct, avg_pf = components[roster_id]
        normalized = (avg_pf - low) / (high - low) if high > low else 0.0
        teams.append(
            TeamPower(
                roster_id=roster_id,
                model_score=round(score_of[roster_id], 3),
                model_rank=rank_of[roster_id],
                all_play_pct=round(all_play_pct, 3),
                normalized_avg_pf=round(normalized, 3),
                win_pct=round(win_pct, 3),
            )
        )

    return PowerRanks(week=effective, teams=teams)

View this file on GitHub at v0.18.0