diff --git a/pyproject.toml b/pyproject.toml index 57f4297..10b4300 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -16,7 +16,7 @@ dependencies = [ "websockets==17.2", # The earner registry (gaming budget terms); stdlib-only, so the root # daemon imports it from the desktop user's site-packages. - "earned-time @ git+https://github.com/kuhyx/utils@earned-time-v0.1.0#subdirectory=earned_time", + "earned-time @ git+https://github.com/kuhyx/utils@earned-time-v0.2.0#subdirectory=earned_time", ] # Optional extras. The `mcp` group is ONLY needed by the MCP server diff --git a/steam_backlog_enforcer/_budget_view.py b/steam_backlog_enforcer/_budget_view.py index 3b061fc..5149a68 100644 --- a/steam_backlog_enforcer/_budget_view.py +++ b/steam_backlog_enforcer/_budget_view.py @@ -14,6 +14,8 @@ from __future__ import annotations from typing import TYPE_CHECKING, Any, Final +from earned_time import EARNERS + from steam_backlog_enforcer._budget_games import ( billing_label, history_view, @@ -166,6 +168,19 @@ def build_rules(rules: PlaytimeRules) -> dict[str, Any]: "leetcode": rules.leetcode_seconds, "reading": rules.reading_seconds, }, + # The registry, in its order: what each earner adds today and what it + # would add once done. The bar renders "+" for every + # entry with nothing earned yet, so a new earner needs no bar change + # beyond an icon -- and no consumer hard-codes a size. + "earners": [ + { + "name": earner.name, + "label": earner.label, + "earned_seconds": rules.earned_seconds.get(earner.name, 0.0), + "bonus_seconds": earner.gaming_minutes * 60, + } + for earner in EARNERS + ], } diff --git a/steam_backlog_enforcer/_playtime_state.py b/steam_backlog_enforcer/_playtime_state.py index b383b0d..445023f 100644 --- a/steam_backlog_enforcer/_playtime_state.py +++ b/steam_backlog_enforcer/_playtime_state.py @@ -126,13 +126,12 @@ class PlaytimeRules: count_launchers: bool enforcement: bool demo: bool - # What earned today's budget, carried here rather than resolved a second - # time: _budget_view reads the breakdown off these fields, so there stays - # exactly one resolution site. + # Today's breakdown, carried so it is resolved once; earned_seconds by name. base_seconds: float = 0.0 workout_seconds: float = 0.0 leetcode_seconds: float = 0.0 reading_seconds: float = 0.0 + earned_seconds: dict[str, float] = field(default_factory=dict) budget_reason: str = "" carry_seconds: float = 0.0 @@ -175,6 +174,7 @@ def rules_for(config: Config, *, demo: bool) -> PlaytimeRules: workout_seconds=0.0 if resolved is None else resolved.workout_seconds, leetcode_seconds=0.0 if resolved is None else resolved.leetcode_seconds, reading_seconds=0.0 if resolved is None else resolved.reading_seconds, + earned_seconds={} if resolved is None else dict(resolved.earned_seconds), budget_reason=( "demo run" if resolved is None diff --git a/steam_backlog_enforcer/tests/test_budget_resolve.py b/steam_backlog_enforcer/tests/test_budget_resolve.py index 6b9ee4e..c498253 100644 --- a/steam_backlog_enforcer/tests/test_budget_resolve.py +++ b/steam_backlog_enforcer/tests/test_budget_resolve.py @@ -26,6 +26,7 @@ _WORKOUT = "steam_backlog_enforcer._workout_budget._fetch_workout_today" _LEETCODE = "steam_backlog_enforcer._leetcode_bonus.read_ledger_solved_today" _LEETCODE_HTTP = "steam_backlog_enforcer._leetcode_bonus._fetch_leetcode_today" _READING = "steam_backlog_enforcer._budget_resolve.read_today" +_LEDGER = "steam_backlog_enforcer._budget_resolve.ledger_answer" _HOUR = 3600.0 @@ -119,6 +120,7 @@ class TestTheEightDays: "workout": 2 * _HOUR, "leetcode": 0.0, "reading": _HOUR, + "anki": 0.0, } @@ -162,11 +164,16 @@ class TestFailingClosed: patch(_WORKOUT, return_value=False), patch(_LEETCODE, return_value=None), patch(_LEETCODE_HTTP, side_effect=OSError("refused")), + patch(_LEDGER, return_value=False), ): unknown = resolve_budget(Config()).reason _leetcode_bonus.reset_cache() _workout_budget.reset_cache() - with patch(_WORKOUT, return_value=False), patch(_LEETCODE, return_value=False): + with ( + patch(_WORKOUT, return_value=False), + patch(_LEETCODE, return_value=False), + patch(_LEDGER, return_value=False), + ): answered = resolve_budget(Config()).reason assert unknown != answered assert "unknown" in unknown diff --git a/steam_backlog_enforcer/tests/test_budget_resolve_reading.py b/steam_backlog_enforcer/tests/test_budget_resolve_reading.py index 767ce38..c8679e0 100644 --- a/steam_backlog_enforcer/tests/test_budget_resolve_reading.py +++ b/steam_backlog_enforcer/tests/test_budget_resolve_reading.py @@ -86,10 +86,14 @@ class TestTheBase: assert resolved.base_seconds == 4 * _HOUR def test_every_later_day_uses_the_lower_floor(self) -> None: - """No drift back to 5h once the cut has happened.""" + """No drift back to 5h once the cut has happened. + + A year on, later earners' cuts (Anki from 2026-10-06) are in force too. + """ with pin_today(AFTER_CUT + timedelta(days=400)): resolved = _resolve(earners=(False, False, False)) - assert resolved.base_seconds == 4 * _HOUR + later_cuts = earned_time.ANKI.gaming_minutes * 60 + assert resolved.base_seconds == 4 * _HOUR - later_cuts class TestTheReadingTerm: diff --git a/steam_backlog_enforcer/tests/test_budget_view.py b/steam_backlog_enforcer/tests/test_budget_view.py index 1f023ba..f2bc34c 100644 --- a/steam_backlog_enforcer/tests/test_budget_view.py +++ b/steam_backlog_enforcer/tests/test_budget_view.py @@ -226,4 +226,5 @@ class TestBuildBudgetSnapshot: "budget_reason", "carry_seconds", "bonuses", + "earners", } diff --git a/steam_backlog_enforcer/tests/test_budget_view_earners.py b/steam_backlog_enforcer/tests/test_budget_view_earners.py new file mode 100644 index 0000000..fc766ab --- /dev/null +++ b/steam_backlog_enforcer/tests/test_budget_view_earners.py @@ -0,0 +1,29 @@ +"""Tests for /api/budget's ``rules.earners``: the registry, listed generically. + +Split from ``test_budget_view.py`` to keep both inside the 250-line cap. +""" + +from __future__ import annotations + +from earned_time import EARNERS + +from steam_backlog_enforcer._budget_view import build_rules +from steam_backlog_enforcer._playtime_state import PlaytimeRules + + +def test_earners_list_the_registry_with_earned_and_size() -> None: + """Every registered earner is listed, so the bar needs no per-earner code.""" + rules = PlaytimeRules( + budget_seconds=0.0, + warn_at=(), + sigkill_after=0.0, + count_launchers=False, + enforcement=True, + demo=False, + earned_seconds={"anki": 1800.0}, + ) + listed = {e["name"]: e for e in build_rules(rules)["earners"]} + assert list(listed) == [e.name for e in EARNERS] + assert listed["anki"]["earned_seconds"] == 1800.0 + assert listed["anki"]["bonus_seconds"] == 1800 + assert listed["reading"]["earned_seconds"] == 0.0 diff --git a/steam_backlog_enforcer/tests/test_ledger_earners.py b/steam_backlog_enforcer/tests/test_ledger_earners.py index 4c81a12..cde0203 100644 --- a/steam_backlog_enforcer/tests/test_ledger_earners.py +++ b/steam_backlog_enforcer/tests/test_ledger_earners.py @@ -13,7 +13,7 @@ from dataclasses import replace from datetime import datetime import logging from typing import TYPE_CHECKING -from unittest.mock import patch +from unittest.mock import call, patch import earned_time import pytest @@ -41,12 +41,14 @@ def _any_credit(_row: dict[str, object], _window: tuple[float, float]) -> bool: return True -ANKI = earned_time.Earner( - name="anki", - label="Anki", +# A hypothetical earner: the real registry already holds anki, so the stand-in +# needs a name no gate uses. +PIANO = earned_time.Earner( + name="piano", + label="Piano", gaming_minutes=30, shutdown_minutes=30, - ledger=".local/share/anki_guard/ledger.json", + ledger=".local/share/piano_guard/ledger.json", match=_any_credit, ) @@ -77,8 +79,8 @@ class TestLedgerAnswer: caplog: pytest's log capture. """ with caplog.at_level(logging.WARNING): - assert ledger_answer(replace(ANKI, ledger=None)) is None - assert "Earner Anki has no ledger" in caplog.text + assert ledger_answer(replace(PIANO, ledger=None)) is None + assert "Earner Piano has no ledger" in caplog.text def test_reads_the_ledger_under_the_home_directory(self, tmp_path: Path) -> None: """A signed credit in ``LEDGER_HOME / earner.ledger`` counts. @@ -86,14 +88,14 @@ class TestLedgerAnswer: Args: tmp_path: pytest's temporary directory (conftest's LEDGER_HOME). """ - assert ANKI.ledger is not None - ledger_dir = (tmp_path / ANKI.ledger).parent + assert PIANO.ledger is not None + ledger_dir = (tmp_path / PIANO.ledger).parent ledger_dir.mkdir(parents=True) write_ledger(ledger_dir, [credit(when=datetime.now().astimezone())]) key = tmp_path / "hmac.key" key.write_bytes(KEY) with patch(f"{_PKG}.HMAC_KEY_FILE", key): - assert ledger_answer(ANKI) is True + assert ledger_answer(PIANO) is True @pytest.mark.parametrize("answer", [True, False]) def test_an_answer_is_cached(self, *, answer: bool) -> None: @@ -103,28 +105,28 @@ class TestLedgerAnswer: answer: The answer the ledger gives. """ with patch("earned_time.done_today", return_value=answer) as read: - assert ledger_answer(ANKI) is answer - assert ledger_answer(ANKI) is answer + assert ledger_answer(PIANO) is answer + assert ledger_answer(PIANO) is answer assert read.call_count == 1 def test_a_failure_is_not_cached(self) -> None: with patch("earned_time.done_today", return_value=None) as read: - assert ledger_answer(ANKI) is None - assert ledger_answer(ANKI) is None + assert ledger_answer(PIANO) is None + assert ledger_answer(PIANO) is None assert read.call_count == 2 def test_reset_cache_forces_a_reread(self) -> None: with patch("earned_time.done_today", return_value=True) as read: - ledger_answer(ANKI) + ledger_answer(PIANO) reset_cache() - ledger_answer(ANKI) + ledger_answer(PIANO) assert read.call_count == 2 def _resolve( - *, answer: bool | None, earner: earned_time.Earner = ANKI + *, answer: bool | None, earner: earned_time.Earner = PIANO ) -> BudgetResolution: - """Resolve with ``earner`` registered, the three built-ins all "no". + """Resolve with ``earner`` registered, every real earner "no". Args: answer: What the extra earner's ledger says. @@ -138,10 +140,12 @@ def _resolve( patch("earned_time.EARNERS", (*earned_time.EARNERS, earner)), patch(_WORKOUT, return_value=False), patch(_LEETCODE, return_value=False), - patch(_ANSWER, return_value=answer) as asked, + patch( + _ANSWER, side_effect=lambda asked: answer if asked is earner else False + ) as asked, ): resolved = resolve_budget(Config()) - asked.assert_called_once_with(earner) + asked.assert_any_call(earner) return resolved @@ -151,23 +155,23 @@ class TestAGenericEarnerInTheBudget: def test_its_credit_adds_its_term(self) -> None: resolved = _resolve(answer=True) assert resolved.seconds == 4.5 * _HOUR - assert resolved.earned_seconds["anki"] == 0.5 * _HOUR - assert resolved.reason.endswith(", Anki credited") + assert resolved.earned_seconds["piano"] == 0.5 * _HOUR + assert resolved.reason.endswith(", Piano credited") def test_no_credit_adds_nothing(self) -> None: resolved = _resolve(answer=False) assert resolved.seconds == 4 * _HOUR - assert resolved.earned_seconds["anki"] == 0.0 - assert "no Anki credited" in resolved.reason + assert resolved.earned_seconds["piano"] == 0.0 + assert "no Piano credited" in resolved.reason def test_unknown_adds_nothing_and_reads_differently(self) -> None: resolved = _resolve(answer=None) assert resolved.seconds == 4 * _HOUR - assert "Anki unknown" in resolved.reason + assert "Piano unknown" in resolved.reason def test_its_penalty_lowers_the_base_by_what_it_pays_back(self) -> None: """Penalty, then reward: skipping it costs exactly its term.""" - penalised = replace(ANKI, penalty_from=AFTER_CUT) + penalised = replace(PIANO, penalty_from=AFTER_CUT) missed = _resolve(answer=False, earner=penalised) earned = _resolve(answer=True, earner=penalised) assert missed.base_seconds == 3.5 * _HOUR @@ -180,8 +184,8 @@ class TestAGenericEarnerInTheBudget: pin_today(AFTER_CUT), patch(_WORKOUT, return_value=False), patch(_LEETCODE, return_value=False), - patch(_ANSWER) as asked, + patch(_ANSWER, return_value=False) as asked, ): resolved = resolve_budget(Config()) - asked.assert_not_called() - assert set(resolved.earned_seconds) == {"workout", "leetcode", "reading"} + assert asked.call_args_list == [call(earned_time.ANKI)] + assert set(resolved.earned_seconds) == {e.name for e in earned_time.EARNERS}