Draft grade

Source: commishdesk/stats/grades.py::compute_draft_grades

def compute_draft_grades(
    league: LeagueModel, consensus: ConsensusMetrics
) -> DraftGrades:
    """Compute one editorial :class:`TeamGrade` per roster in ``league``.

    Pure, deterministic, offline. A valid ``LeagueModel`` plus its
    ``ConsensusMetrics`` in, a ``DraftGrades`` out; two calls on one input return
    an equal ``model_dump()``. A roster whose every pick is ``no_consensus`` gets
    ``draft_score`` ``0.0``, ``premium_picks`` ``0``, ``driving_picks`` ``[]`` --
    ``format_fit`` still comes from the drafted positions -- and never raises.
    """
    superflex = league.format.is_superflex_or_2qb
    te_premium = league.format.te_premium

    position_by_pick_no = {pick.pick_no: (pick.player.position or "") for pick in league.picks}

    picks_by_roster: dict[str, list] = {}
    for pick_row in consensus.picks:
        picks_by_roster.setdefault(pick_row.roster_id, []).append(pick_row)

    qb_by_roster: dict[str, int] = {}
    for pick in league.picks:
        if pick.player.position == "QB":
            qb_by_roster[pick.roster_id] = qb_by_roster.get(pick.roster_id, 0) + 1

    team_grades: list[TeamGrade] = []
    for team in league.teams:
        roster_picks = picks_by_roster.get(team.roster_id, [])

        total = 0.0
        premium_picks = 0
        premium_te = 0
        contributions: list[tuple[float, int]] = []  # (abs contribution, pick_no)
        for pick_row in roster_picks:
            slot = pick_row.consensus_slot
            # premium_picks / premium_te are counted from consensus_slot alone
            # (spec: "count of picks with consensus_slot <= 10", no delta dependency).
            if slot is None:
                continue
            if slot <= PREMIUM_SLOT:
                premium_picks += 1
            if (
                slot <= PREMIUM_TE_SLOT
                and position_by_pick_no.get(pick_row.pick_no) == "TE"
            ):
                premium_te += 1
            # draft_score contribution + driving-pick math need delta.
            if pick_row.delta is None:
                continue
            contribution = pick_row.delta * _weight(slot)
            total += contribution
            if abs(contribution) >= DRIVING_CUTOFF:
                contributions.append((abs(contribution), pick_row.pick_no))

        draft_score = round(total, 1) or 0.0

        format_fit = 0
        if superflex:
            qb_count = qb_by_roster.get(team.roster_id, 0)
            if qb_count >= 1:
                format_fit += 2
            if qb_count >= 2:
                format_fit += 2
        if te_premium:
            format_fit += premium_te

        grade_input = round(draft_score + PREMIUM_BONUS * premium_picks + format_fit, 1) or 0.0

        letter = _letter_for(grade_input)
        if premium_picks >= 2 and letter in _FLOOR_LETTERS:
            letter = _FLOOR_LETTER

        contributions.sort(key=lambda item: (-item[0], item[1]))
        driving_picks = sorted(
            {pick_no for _, pick_no in contributions[:MAX_DRIVING_PICKS]}
        )

        team_grades.append(
            TeamGrade(
                roster_id=team.roster_id,
                draft_score=draft_score,
                premium_picks=premium_picks,
                format_fit=format_fit,
                grade_input=grade_input,
                letter=letter,
                driving_picks=driving_picks,
            )
        )

    return DraftGrades(teams=team_grades, grade_method=GRADE_METHOD)

View this file on GitHub at v0.18.0