mirror of
https://github.com/ChuckBuilds/LEDMatrix.git
synced 2026-10-13 02:26:37 +00:00
feat(common): sports_rankings -- the reconciled rankings (sports family 8) (#789)
* feat(common): sports_rankings -- the reconciled rankings family (sports family 8) New hardware-free module src/common/sports_rankings.py, copied from ledmatrix-plugins claude/family8-reconcile once the nine scoreboards made _fetch_team_rankings, _choose_poll (three bodies each), _load_division_team_ids, _passes_other_filters, _best_rank and _is_ranked_game (two each) one body each. All of them live on the plugins' SportsCore, so one mixin, SportsRankingsMixin, carries exactly those six plus _ranked_positions and _poll_season_ended and the constants they read; no manager gains a method it lacks today. - Ranks are kept by ESPN team id as well as abbreviation, and a game with ids is ranked by id (ESPN lists Ohio State and Ohio State Newark both as OSU). The badge still reads the abbreviation table. - A poll whose season's endDate has passed loads nothing, so no badge shows and the "ranked" filter fails open between seasons (ESPN served April's college basketball poll on 2026-10-12); read from the payload, no calendar, no sport names. - College football's division rosters are asked for the season year (football's July rule; only that league has rosters, so no seam). - choose_top_division_poll(): the one poll rule, for the dynamic team resolvers that expand AP_TOP_n. - test/test_sports_rankings.py: the plugins' pinned cases (poll choice, which leagues are asked, payload shapes, hourly cache, the finished-season rows, the rosters' season year and caching, ranked/best rank/filter over colliding abbreviations), plus the host contract. Mutation-checked. - test/test_sports_rankings_parity.py: with LEDMATRIX_PLUGINS, compares each body and constant with every plugin copy. Passes against claude/family8-reconcile; fails against the pre-reconcile tree. - mypy ratchet, src/common/README.md, CHANGELOG (Unreleased, New modules). - sports_shared and sports_rotation docstrings: the three methods leave the "stay per-plugin" list. - docs/SPORTS_UNIFICATION.md: family 8 status and decisions; item 8 restated to match what measuring found (the standings branch never ran; the season year only matters to college football). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * docs: cite ledmatrix-plugins #645 for the family 8 reconcile Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * ci: re-run code scanning (the Python analysis job never started) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Chuck
@@ -0,0 +1,379 @@
|
||||
"""src.common.sports_rankings: the poll, the tables, the season, the filter.
|
||||
|
||||
The cases follow ledmatrix-plugins' ``scripts/test_rankings.py`` (the tables
|
||||
the family 8 reconcile was checked against); the expected values are its
|
||||
columns, which agree across all nine scoreboards for everything this module
|
||||
does. The host is the mixin over core's ``SportsCoreSharedMixin``
|
||||
(``_league_has_rankings``, ``_game_divisions``) and ``SportsRotationMixin``
|
||||
(``_rankings_loaded``), with a data source and an HTTP session that answer
|
||||
from fixtures shaped like ESPN's payloads. Nothing reaches the network.
|
||||
"""
|
||||
|
||||
import ast
|
||||
import logging
|
||||
from datetime import datetime, timezone
|
||||
from pathlib import Path
|
||||
from unittest.mock import MagicMock
|
||||
|
||||
import pytest
|
||||
|
||||
from src.common import sports_rankings
|
||||
from src.common.sports_favorites import SportsFavoritesMixin
|
||||
from src.common.sports_helpers import SportsHelpersMixin
|
||||
from src.common.sports_rankings import SportsRankingsMixin, choose_top_division_poll
|
||||
from src.common.sports_rotation import SportsRotationMixin
|
||||
from src.common.sports_shared import SportsCoreSharedMixin
|
||||
|
||||
LOG = logging.getLogger("test_sports_rankings")
|
||||
CORE_API = "https://sports.core.api.espn.com/v2/sports/"
|
||||
|
||||
UGA, ND, OSU, TEX, VAN, SDSU = ("61", "UGA"), ("87", "ND"), ("194", "OSU"), \
|
||||
("251", "TEX"), ("238", "VAN"), ("21", "SDSU")
|
||||
SDST, NDSU, NEWARK, FRST, DEN = ("2571", "SDST"), ("2449", "NDSU"), \
|
||||
("9194", "OSU"), ("9001", "FRST"), ("2172", "DEN")
|
||||
FBS_IDS, FCS_IDS = (UGA, ND, OSU, TEX, VAN, SDSU), (SDST, NDSU)
|
||||
|
||||
|
||||
def poll(name, kind, *teams, **extra):
|
||||
return {"name": name, "shortName": name, "type": kind, **extra, "ranks": [
|
||||
{"current": n, "previous": n, "team": {"id": tid, "abbreviation": abbr}}
|
||||
for n, (tid, abbr) in enumerate(teams, 1)]}
|
||||
|
||||
|
||||
AP = poll("AP Top 25", "ap", UGA, ND, OSU, SDSU)
|
||||
COACHES = poll("AFCA Coaches Poll", "usa", ND, UGA, TEX)
|
||||
CFP = poll("College Football Playoff Rankings", "cfp", OSU, UGA)
|
||||
FCS = poll("FCS Coaches Poll", "fcs", NDSU, SDST)
|
||||
D2 = poll("AFCA Division II Coaches Poll", "afca", FRST)
|
||||
SEEDS = poll("NCAA Men's Hockey Tournament Seedings", "tournament", DEN)
|
||||
USCHO = poll("USCHO Men's Poll", "USCHOMENSPOLL", DEN, ND)
|
||||
AP_TABLE = {"ND": 2, "OSU": 3, "SDSU": 4, "UGA": 1}
|
||||
AP_IDS = {194: 3, 21: 4, 61: 1, 87: 2}
|
||||
|
||||
|
||||
def at(text):
|
||||
return datetime.fromisoformat(text).replace(tzinfo=timezone.utc).timestamp()
|
||||
|
||||
|
||||
class Clock:
|
||||
def __init__(self):
|
||||
self.now = 100_000.0
|
||||
|
||||
def __call__(self):
|
||||
return self.now
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def clock(monkeypatch):
|
||||
c = Clock()
|
||||
monkeypatch.setattr(sports_rankings.time, "time", c)
|
||||
monkeypatch.setattr(sports_rankings.time, "monotonic", c)
|
||||
return c
|
||||
|
||||
|
||||
class Rosters:
|
||||
"""The core API's division rosters, published up to ``last`` season."""
|
||||
|
||||
def __init__(self, last=2026):
|
||||
self.last, self.urls = last, []
|
||||
|
||||
def get(self, url, params=None, timeout=None):
|
||||
self.urls.append(url[len(CORE_API):])
|
||||
season, group = url.split("/seasons/")[1].split("/")[0], url.split("/groups/")[1][:2]
|
||||
ids = {"80": FBS_IDS, "81": FCS_IDS}[group] if int(season) <= self.last else ()
|
||||
resp = MagicMock()
|
||||
resp.json.return_value = {"items": [{"$ref": f"{CORE_API}x/teams/{t}?lang=en"}
|
||||
for t, _ in ids]}
|
||||
return resp
|
||||
|
||||
|
||||
class Host(SportsRankingsMixin, SportsRotationMixin, SportsCoreSharedMixin,
|
||||
SportsFavoritesMixin, SportsHelpersMixin):
|
||||
"""A scoreboard SportsCore as far as the rankings reach."""
|
||||
|
||||
sport = "football"
|
||||
|
||||
def __init__(self, league="college-football", payload=None, quality="any",
|
||||
divisions=(), rosters=None):
|
||||
self.logger = LOG
|
||||
self.league = league
|
||||
self.data_source = MagicMock()
|
||||
self.data_source.fetch_standings.return_value = (
|
||||
{"rankings": [AP, COACHES]} if payload is None else payload)
|
||||
self.session = rosters or Rosters()
|
||||
self.cache_manager = MagicMock()
|
||||
self.cache_manager.get.return_value = None
|
||||
self._team_rankings_cache, self._ranked_team_ids = {}, {}
|
||||
self._rankings_cache_timestamp, self._rankings_cache_duration = 0, 3600
|
||||
self._division_team_ids, self._division_loaded_at = None, 0.0
|
||||
self.other_games_min_quality = quality
|
||||
self.other_games_divisions = list(divisions)
|
||||
|
||||
|
||||
def tables(host):
|
||||
return host._team_rankings_cache, host._ranked_team_ids
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Which poll
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
POLL_SETS = [
|
||||
([AP, COACHES], "AP Top 25"),
|
||||
([COACHES, AP], "AFCA Coaches Poll"),
|
||||
([CFP, AP, COACHES], "College Football Playoff Rankings"),
|
||||
([FCS, D2, AP, COACHES], "AP Top 25"),
|
||||
([FCS, D2], None),
|
||||
([poll("Coaches Poll", "fcs", NDSU), AP], "AP Top 25"), # by type alone
|
||||
([SEEDS, USCHO], "USCHO Men's Poll"),
|
||||
([], None),
|
||||
(None, None),
|
||||
]
|
||||
|
||||
|
||||
@pytest.mark.parametrize("blocks, expected", POLL_SETS)
|
||||
def test_the_poll_chosen(blocks, expected):
|
||||
assert Host()._choose_poll(blocks).get("name") == expected
|
||||
assert choose_top_division_poll(blocks).get("name") == expected
|
||||
|
||||
|
||||
def test_an_untyped_unnamed_block_counts():
|
||||
"""An exclude list: a block ESPN invents is a poll unless it says otherwise."""
|
||||
assert choose_top_division_poll([{"ranks": []}]) == {"ranks": []}
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# The tables
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
@pytest.mark.parametrize("league, asked", [
|
||||
("college-football", True), ("mens-college-basketball", True),
|
||||
("usa.ncaa.m.1", True), ("nfl", False), ("nba", False), ("eng.1", False)])
|
||||
def test_only_a_league_with_a_poll_is_asked(clock, league, asked):
|
||||
host = Host(league)
|
||||
host._fetch_team_rankings()
|
||||
assert host.data_source.fetch_standings.called is asked
|
||||
assert tables(host) == ((AP_TABLE, AP_IDS) if asked else ({}, {}))
|
||||
|
||||
|
||||
@pytest.mark.parametrize("payload, abbr, ids", [
|
||||
({}, {}, {}),
|
||||
({"rankings": []}, {}, {}),
|
||||
({"rankings": None}, {}, {}),
|
||||
({"rankings": [{"name": "AP Top 25", "type": "ap"}]}, {}, {}),
|
||||
({"rankings": [{"name": "AP Top 25", "type": "ap", "ranks": [
|
||||
{"current": 0, "team": {"id": "61", "abbreviation": "UGA"}},
|
||||
{"current": -1, "team": {"id": "87", "abbreviation": "ND"}},
|
||||
{"team": {"id": "194", "abbreviation": "OSU"}},
|
||||
{"current": 4, "team": {"id": "251", "abbreviation": "TEX"}}]}]},
|
||||
{"TEX": 4}, {251: 4}),
|
||||
({"rankings": [{"name": "AP Top 25", "type": "ap", "ranks": [
|
||||
{"current": 1},
|
||||
{"current": 2, "team": {"id": "87"}},
|
||||
{"current": 3, "team": {"id": "abc", "abbreviation": "OSU"}},
|
||||
{"current": 4, "team": {"abbreviation": "TEX"}}]}]},
|
||||
{"OSU": 3, "TEX": 4}, {87: 2}),
|
||||
])
|
||||
def test_payload_shapes(clock, payload, abbr, ids):
|
||||
host = Host(payload=payload)
|
||||
host._fetch_team_rankings()
|
||||
assert tables(host) == (abbr, ids)
|
||||
assert host._rankings_cache_timestamp == clock.now # an empty answer is cached too
|
||||
|
||||
|
||||
def test_a_failed_fetch_is_not_cached(clock):
|
||||
host = Host(payload={"rankings": {"name": "AP Top 25"}}) # not a list
|
||||
assert host._fetch_team_rankings() == {}
|
||||
assert host._rankings_cache_timestamp == 0
|
||||
|
||||
|
||||
@pytest.mark.parametrize("payload", [{"rankings": [AP, COACHES]}, {"rankings": []}])
|
||||
def test_rankings_are_fetched_hourly(clock, payload):
|
||||
host = Host(payload=payload)
|
||||
calls = []
|
||||
for step in (0, 60, 3599, 3601):
|
||||
clock.now = 100_000.0 + step
|
||||
before = host.data_source.fetch_standings.call_count
|
||||
host._fetch_team_rankings()
|
||||
calls.append(host.data_source.fetch_standings.call_count - before)
|
||||
assert calls == [1, 0, 0, 1]
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# A poll from a season that has ended
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
@pytest.mark.parametrize("end, now, kept", [
|
||||
("2026-04-08T06:59Z", "2026-10-12T12:00", False), # college basketball in October
|
||||
("2026-04-08T06:59Z", "2026-04-08T06:58", True),
|
||||
("2026-04-08T06:59Z", "2026-04-08T06:59", True), # at endDate: not yet over
|
||||
("2026-04-08T06:59Z", "2026-04-08T07:00", False),
|
||||
("2027-01-28T07:59Z", "2027-01-10T12:00", True), # bowl week
|
||||
("2027-04-08T06:59Z", "2026-11-03T12:00", True), # the new season's first poll
|
||||
("2026-04-08T06:59:00Z", "2026-10-12T12:00", False),
|
||||
("April", "2026-10-12T12:00", True), # unreadable: current
|
||||
(None, "2026-10-12T12:00", True), # no season block
|
||||
])
|
||||
def test_a_finished_seasons_poll_loads_nothing(clock, end, now, kept):
|
||||
block = dict(AP, season={"year": 2026, "endDate": end}) if end else AP
|
||||
host = Host(payload={"rankings": [block, COACHES]})
|
||||
clock.now = at(now)
|
||||
host._fetch_team_rankings()
|
||||
assert tables(host) == ((AP_TABLE, AP_IDS) if kept else ({}, {}))
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Division rosters
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class Frozen(datetime):
|
||||
at = datetime(2026, 10, 12, 12)
|
||||
|
||||
@classmethod
|
||||
def now(cls, tz=None):
|
||||
return cls.at
|
||||
|
||||
|
||||
@pytest.mark.parametrize("today, season, sizes", [
|
||||
("2026-01-15", 2025, (6, 2)), ("2026-06-30", 2025, (6, 2)),
|
||||
("2026-07-01", 2026, (6, 2)), ("2026-10-12", 2026, (6, 2)),
|
||||
("2026-12-31", 2026, (6, 2)), ("2027-01-15", 2026, (6, 2))])
|
||||
def test_the_rosters_are_for_the_season_year(clock, monkeypatch, today, season, sizes):
|
||||
monkeypatch.setattr(sports_rankings, "datetime", Frozen)
|
||||
Frozen.at = datetime.fromisoformat(today)
|
||||
host = Host()
|
||||
rosters = host._load_division_team_ids()
|
||||
assert host.session.urls == [
|
||||
f"football/leagues/college-football/seasons/{season}/types/2/groups/{g}/teams"
|
||||
for g in (80, 81)]
|
||||
assert (len(rosters["fbs"]), len(rosters["fcs"])) == sizes
|
||||
|
||||
|
||||
def test_no_rosters_outside_college_football(clock):
|
||||
host = Host("mens-college-basketball")
|
||||
assert host._load_division_team_ids() == {}
|
||||
assert host.session.urls == []
|
||||
|
||||
|
||||
@pytest.mark.parametrize("last, cached, calls, sizes", [
|
||||
(2026, None, [2, 0, 0, 2], (6, 2)), # a day
|
||||
(0, None, [2, 0, 2, 2], (0, 0)), # empty: retried after 10 minutes
|
||||
(2026, "cache", [0, 0, 0, 0], (2, 1)), # the cache manager's copy
|
||||
])
|
||||
def test_roster_caching(clock, last, cached, calls, sizes):
|
||||
host = Host(rosters=Rosters(last))
|
||||
if cached:
|
||||
host.cache_manager.get.side_effect = lambda key, *a, **k: (
|
||||
["61", "87"] if key.endswith("_80") else ["2571"])
|
||||
made = []
|
||||
for step in (0, 60, 601, 86_401):
|
||||
clock.now = 100_000.0 + step
|
||||
before = len(host.session.urls)
|
||||
host._load_division_team_ids()
|
||||
made.append(len(host.session.urls) - before)
|
||||
rosters = host._division_team_ids
|
||||
assert made == calls
|
||||
assert (len(rosters["fbs"]), len(rosters["fcs"])) == sizes
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Ranked games and the filter
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
GAMES = {
|
||||
"UGA v TEX": (UGA, TEX),
|
||||
"TEX v VAN": (TEX, VAN),
|
||||
"OSU v VAN": (OSU, VAN),
|
||||
"Newark 'OSU' v VAN": (NEWARK, VAN),
|
||||
"SDSU v SDST": (SDSU, SDST),
|
||||
"SDST v NDSU": (SDST, NDSU),
|
||||
"'OSU' v VAN, no ids": ((None, "OSU"), (None, "VAN")),
|
||||
"61 v 238, no abbrs": (("61", None), ("238", None)),
|
||||
}
|
||||
|
||||
|
||||
def game(label):
|
||||
g = {"id": "g"}
|
||||
for side, (tid, abbr) in zip(("home", "away"), GAMES[label]):
|
||||
if tid is not None:
|
||||
g[f"{side}_id"] = tid
|
||||
if abbr is not None:
|
||||
g[f"{side}_abbr"] = abbr
|
||||
return g
|
||||
|
||||
|
||||
def loaded(**kwargs):
|
||||
host = Host(**kwargs)
|
||||
host._fetch_team_rankings()
|
||||
return host
|
||||
|
||||
|
||||
@pytest.mark.parametrize("label, best", [
|
||||
("UGA v TEX", 1), ("TEX v VAN", 99), ("OSU v VAN", 3),
|
||||
("Newark 'OSU' v VAN", 99), # same abbreviation, another school: by id
|
||||
("SDSU v SDST", 4), ("SDST v NDSU", 99),
|
||||
("'OSU' v VAN, no ids", 3), # no ids: by abbreviation
|
||||
("61 v 238, no abbrs", 1)])
|
||||
def test_ranked_and_best_rank(clock, label, best):
|
||||
host = loaded()
|
||||
assert host._best_rank(game(label)) == best
|
||||
assert host._is_ranked_game(game(label)) is (best != 99)
|
||||
|
||||
|
||||
#: filter -> (quality, divisions, poll loaded?, kept: one Y/. per GAMES entry)
|
||||
FILTERS = {
|
||||
"any": ("any", (), True, "YYYYYYYY"),
|
||||
"ranked": ("ranked", (), True, "Y.Y.Y.YY"),
|
||||
"ranked, no poll loaded": ("ranked", (), False, "YYYYYYYY"),
|
||||
"any, fbs": ("any", ("fbs",), True, "YYYYY.YY"),
|
||||
"ranked, fbs": ("ranked", ("fbs",), True, "Y.Y.Y.YY"),
|
||||
"any, fcs": ("any", ("fcs",), True, "....YYY."),
|
||||
}
|
||||
|
||||
|
||||
@pytest.mark.parametrize("name", FILTERS)
|
||||
def test_passes_other_filters(clock, monkeypatch, name):
|
||||
quality, divisions, with_poll, kept = FILTERS[name]
|
||||
monkeypatch.setattr(sports_rankings, "datetime", Frozen)
|
||||
Frozen.at = datetime(2026, 10, 12, 12)
|
||||
host = loaded(payload={"rankings": [AP, COACHES] if with_poll else []},
|
||||
quality=quality, divisions=divisions)
|
||||
assert "".join("Y" if host._passes_other_filters(game(g)) else "." for g in GAMES) == kept
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Carrier and host contract
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
MEMBERS = ["_DIVISION_CACHE_TTL", "_DIVISION_GROUPS_BY_LEAGUE", "_DIVISION_RETRY_SECONDS",
|
||||
"_NON_TOP_POLL_NAMES", "_NON_TOP_POLL_TYPES", "_best_rank", "_choose_poll",
|
||||
"_fetch_team_rankings", "_is_ranked_game", "_load_division_team_ids",
|
||||
"_passes_other_filters", "_poll_season_ended", "_ranked_positions"]
|
||||
|
||||
|
||||
def _self_reads():
|
||||
tree = ast.parse(Path(sports_rankings.__file__).read_text(encoding="utf-8"))
|
||||
return {node.attr for node in ast.walk(tree)
|
||||
if isinstance(node, ast.Attribute) and isinstance(node.ctx, ast.Load)
|
||||
and isinstance(node.value, ast.Name) and node.value.id == "self"}
|
||||
|
||||
|
||||
class TestHostContract:
|
||||
def test_the_mixin_carries_only_the_family(self):
|
||||
"""Every scoreboard's SportsCore has all of them, so adopting it adds none."""
|
||||
assert sorted(n for n in vars(SportsRankingsMixin)
|
||||
if not n.startswith("__")) == MEMBERS
|
||||
|
||||
def test_every_host_read_is_documented(self):
|
||||
own = set(MEMBERS)
|
||||
undocumented = sorted(n for n in _self_reads() - own
|
||||
if f"``{n}``" not in sports_rankings.__doc__)
|
||||
assert undocumented == [], f"read but not in the host contract: {undocumented}"
|
||||
|
||||
def test_no_other_shared_mixin_defines_these(self):
|
||||
from src.common import sports_display_rules, sports_shared
|
||||
others = [sports_shared.SportsCoreSharedMixin, sports_shared.SportsRecentSharedMixin,
|
||||
sports_shared.SportsLiveSharedMixin, SportsHelpersMixin,
|
||||
SportsFavoritesMixin, SportsRotationMixin,
|
||||
sports_display_rules.SportsGameRulesMixin]
|
||||
assert [m for m in MEMBERS if any(m in vars(o) for o in others)] == []
|
||||
@@ -0,0 +1,132 @@
|
||||
"""sports_rankings still matches every plugin copy.
|
||||
|
||||
``src.common.sports_rankings`` was copied from the scoreboards once family 8
|
||||
had made each method one body in all nine ``SportsCore`` classes:
|
||||
``_choose_poll``, ``_fetch_team_rankings``, ``_poll_season_ended``,
|
||||
``_load_division_team_ids``, ``_ranked_positions``, ``_is_ranked_game``,
|
||||
``_best_rank`` and ``_passes_other_filters``, with the class constants they
|
||||
read. The plugins delete their copies once they floor on the release that
|
||||
ships this module. Until each has, a copy that changes on its own is a fix one
|
||||
side has and the other lacks.
|
||||
|
||||
Point LEDMATRIX_PLUGINS at a ledmatrix-plugins checkout and each method is
|
||||
compared with every plugin copy using ``scripts/sports_drift_report.py``'s own
|
||||
normalisation (the AST with docstrings and annotations dropped), plus the
|
||||
decorators, and each constant a plugin still defines by its expression. A copy that is
|
||||
gone counts as adopted when the plugin's ``sports.py`` names the module.
|
||||
Without the variable this skips: core CI has no plugins checkout.
|
||||
"""
|
||||
|
||||
import ast
|
||||
import importlib.util
|
||||
import os
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from src.common import sports_rankings
|
||||
|
||||
REPO = Path(__file__).resolve().parents[1]
|
||||
SPORTS = ("afl", "baseball", "basketball", "football", "hockey", "lacrosse",
|
||||
"nrl", "soccer", "ufc")
|
||||
CARRIER, MIXIN = "SportsCore", "SportsRankingsMixin"
|
||||
METHODS = ("_choose_poll", "_fetch_team_rankings", "_poll_season_ended",
|
||||
"_load_division_team_ids", "_ranked_positions", "_is_ranked_game",
|
||||
"_best_rank", "_passes_other_filters")
|
||||
CONSTANTS = ("_NON_TOP_POLL_TYPES", "_NON_TOP_POLL_NAMES", "_DIVISION_GROUPS_BY_LEAGUE",
|
||||
"_DIVISION_CACHE_TTL", "_DIVISION_RETRY_SECONDS")
|
||||
|
||||
|
||||
def _drift_report():
|
||||
"""scripts/sports_drift_report.py, loaded by path (scripts/ is no package)."""
|
||||
spec = importlib.util.spec_from_file_location(
|
||||
"sports_drift_report", REPO / "scripts" / "sports_drift_report.py")
|
||||
module = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(module)
|
||||
return module
|
||||
|
||||
|
||||
DRIFT = _drift_report()
|
||||
|
||||
|
||||
def _plugins_root():
|
||||
root = DRIFT.resolve_plugins_dir(os.environ.get("LEDMATRIX_PLUGINS"))
|
||||
if root is None:
|
||||
pytest.skip("set LEDMATRIX_PLUGINS to a ledmatrix-plugins checkout to "
|
||||
"compare this module against the plugin copies")
|
||||
return root
|
||||
|
||||
|
||||
def _class(tree, name):
|
||||
return next(n for n in tree.body if isinstance(n, ast.ClassDef) and n.name == name)
|
||||
|
||||
|
||||
def _method(cls, name):
|
||||
return next((n for n in cls.body
|
||||
if isinstance(n, ast.FunctionDef) and n.name == name), None)
|
||||
|
||||
|
||||
def _constant(cls, name):
|
||||
"""The value a class body assigns to ``name`` (plain or annotated), or None."""
|
||||
for node in cls.body:
|
||||
if isinstance(node, ast.Assign) and any(
|
||||
isinstance(t, ast.Name) and t.id == name for t in node.targets):
|
||||
return node.value
|
||||
if isinstance(node, ast.AnnAssign) and isinstance(node.target, ast.Name) \
|
||||
and node.target.id == name:
|
||||
return node.value
|
||||
return None
|
||||
|
||||
|
||||
def _fingerprint(node):
|
||||
return (DRIFT._digest(node, DRIFT._Canonical()),
|
||||
tuple(ast.unparse(d) for d in node.decorator_list))
|
||||
|
||||
|
||||
def _plugin_tree(root, sport):
|
||||
source = (root / f"{sport}-scoreboard" / "sports.py").read_text(encoding="utf-8")
|
||||
return source, ast.parse(source)
|
||||
|
||||
|
||||
OURS = _class(ast.parse(Path(sports_rankings.__file__).read_text(encoding="utf-8")), MIXIN)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("sport, name", [(s, n) for s in SPORTS for n in METHODS])
|
||||
def test_every_remaining_plugin_copy_matches(sport, name):
|
||||
source, tree = _plugin_tree(_plugins_root(), sport)
|
||||
copy = _method(_class(tree, CARRIER), name)
|
||||
if copy is None:
|
||||
assert sports_rankings.__name__ in source, (
|
||||
f"{sport}: no {name} on {CARRIER} and no {sports_rankings.__name__} import")
|
||||
else:
|
||||
assert _fingerprint(copy) == _fingerprint(_method(OURS, name)), (
|
||||
f"{CARRIER}.{name} in {sport} differs from sports_rankings. "
|
||||
f"Port the change to both, or stop treating it as shared.")
|
||||
|
||||
|
||||
@pytest.mark.parametrize("sport", SPORTS)
|
||||
def test_the_plugin_constants_match(sport):
|
||||
_, tree = _plugin_tree(_plugins_root(), sport)
|
||||
core = _class(tree, CARRIER)
|
||||
for name in CONSTANTS:
|
||||
value = _constant(core, name)
|
||||
if value is not None:
|
||||
assert ast.dump(value) == ast.dump(_constant(OURS, name)), f"{sport}: {name}"
|
||||
|
||||
|
||||
@pytest.mark.parametrize("sport", SPORTS)
|
||||
def test_no_other_plugin_class_carries_a_copy(sport):
|
||||
"""A copy on another class would shadow the shared one for that class."""
|
||||
_, tree = _plugin_tree(_plugins_root(), sport)
|
||||
strays = [f"{node.name}.{name}" for node in tree.body if isinstance(node, ast.ClassDef)
|
||||
for name in METHODS if node.name != CARRIER and _method(node, name) is not None]
|
||||
assert strays == []
|
||||
|
||||
|
||||
def test_the_drift_report_calls_them_identical():
|
||||
families = DRIFT.build(_plugins_root(), ("sports.py",))
|
||||
rows = {(r["file"], r["family"]): r
|
||||
for r in (DRIFT.summarise(k, v) for k, v in families.items())}
|
||||
for name in METHODS:
|
||||
row = rows.get(("sports.py", name))
|
||||
assert row is None or row["worst_class_variants"] == 1, name
|
||||
Reference in New Issue
Block a user