Stakes and next week

Source: commishdesk/stats/stakes.py::_outlooks

def _outlooks(week: WeekModel, league: LeagueModel, standings: Standings) -> dict[str, _Outlook]:
    """Every roster's :class:`_Outlook`, keyed by ``roster_id``.

    All-empty when the league declares no rosters or no ``playoff_week_start``.
    Once the previewed week reaches ``playoff_week_start`` the clinch and
    elimination flags are still computed (with no games left they are the final
    regular-season picture) but no tag is emitted. A league that declares no
    ``league.format.playoff`` keeps the division picture but emits no playoff
    tag."""
    roster_ids = sorted((roster.roster_id for roster in week.rosters), key=_sort_key)
    if not roster_ids or week.playoff_week_start is None:
        return {roster_id: _NO_OUTLOOK for roster_id in roster_ids}
    emit_tags = not _stand_down(week)

    records = {team.roster_id: team for team in standings.teams}
    cur: dict[str, float] = {}
    for roster_id in roster_ids:
        record = records.get(roster_id)
        cur[roster_id] = _win_equivalent(record.wins, record.ties) if record is not None else 0.0
    remaining = _remaining_games(week, standings)
    ceiling = {roster_id: cur[roster_id] + remaining for roster_id in roster_ids}

    playoff = league.format.playoff
    bracket = min(playoff.bracket_teams, len(roster_ids)) if playoff is not None else None
    byes = bye_count(bracket) if bracket is not None else 0
    picture = standings.playoff_picture
    seeded = picture if picture is not None and picture.source == "commissioner" else None

    division_of = {team.roster_id: team.division_id for team in league.teams}
    declared = {division.id for division in league.format.divisions}

    outlooks: dict[str, _Outlook] = {}
    for roster_id in roster_ids:
        others = [other for other in roster_ids if other != roster_id]
        others_cur = [cur[other] for other in others]
        others_max = [ceiling[other] for other in others]

        tags: set[str] = set()
        clinched_playoff = False
        clinched_bye = False
        eliminated = False

        if bracket is not None and bracket > 0:
            ahead_cur = sum(1 for value in others_cur if value > ceiling[roster_id])
            catchers = sum(1 for value in others_max if value >= cur[roster_id])
            eliminated = ahead_cur >= bracket
            clinched_playoff = catchers <= bracket - 1
            clinched_bye = byes > 0 and catchers <= byes - 1

            if byes > 0 and not clinched_bye and ahead_cur <= byes - 1:
                tags.add("bye_seed")
            if not clinched_playoff and not eliminated:
                tags.add("wildcard_race")
            if eliminated:
                tags.add("draft_position")
            elif sum(1 for value in others_cur if value > ceiling[roster_id] - 1) >= bracket:
                tags.add("elimination")

        if seeded is not None:
            # A commissioner override fixes the bracket: the picture, not the
            # records, decides membership, so stakes must agree with it.
            in_bracket = roster_id in seeded.in_bracket
            clinched_playoff = in_bracket
            clinched_bye = roster_id in seeded.byes
            eliminated = not in_bracket
            tags -= {"bye_seed", "wildcard_race", "elimination", "draft_position"}
            if eliminated:
                tags.add("draft_position")

        division_id = division_of.get(roster_id)
        clinched_division = False
        if division_id is not None and division_id in declared:
            rivals = [
                other for other in others if division_of.get(other) == division_id
            ]
            if rivals:
                rival_cur = [cur[rival] for rival in rivals]
                rival_max = [ceiling[rival] for rival in rivals]
                clinched_division = not any(value >= cur[roster_id] for value in rival_max)
                if not clinched_division and not any(value > ceiling[roster_id] for value in rival_cur):
                    tags.add("division_race")

        outlooks[roster_id] = _Outlook(
            tags=frozenset(tags) if emit_tags else frozenset(),
            clinched_playoff=clinched_playoff,
            clinched_bye=clinched_bye,
            eliminated=eliminated,
            clinched_division=clinched_division,
        )
    return outlooks

View this file on GitHub at v0.18.0