steam-backlog-enforcer/steam_backlog_enforcer/_budget_resolve.py
Krzysztof kuhy Rudnicki e77814e0a7 Drop gaming budget from 2026-11-16
Kuhy removed the daily gaming/leisure budget; only shutdown time
(screen-locker) stays. One gate, _gaming_gate.gaming_enforced_on(day),
wraps earned_time 0.22.0 gaming_enforced; resolve_budget carries it as
BudgetResolution.enforced and rules_for as PlaytimeRules.gaming_enforced.

Unlimited day: no warning, no cutoff, no kill, no leisure billing or
leisure kill; a block left from an earlier day is lifted. Time is still
billed for history. Backlog game choice and launch scope are untouched.
MCP, CLI and /api/budget report unlimited with null numbers; the web UI
paints the no-cap icon, no meter. Past-day history keeps working.

Failure modes: switch unreadable or day key not a date -> fail OPEN
(unlimited), logged ERROR once per cause, never raises, so the 5 h
fallback is never enforced and the daemon never crashes. Demo runs stay
enforced. The playtime_state.json schema is unchanged.

Pins earned-time-v0.22.0 and leisure-watch-v0.2.8 (freshness gate; only
golive.py changed, procscan untouched). DOCS-web-control-api notes null fields.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01WzxdWViGJJaqBKGr1Hbppr
2026-11-16 16:16:52 +01:00

246 lines
9.8 KiB
Python

"""Today's gaming budget: a floor, plus whatever today earned.
Every number lives in the shared earner registry (``earned_time``,
kuhyx/utils), which screen-locker reads for the shutdown time too. The budget
is its sum, capped at the gaming ceiling (8h):
base (4h) + workout (2h) + LeetCode (1h) + reading (1h) + ...
The base is 5h minus every penalised earner's cut once its day arrives
(book-guard's reading hour, from 2026-10-01) -- and, from earned_time 0.6, not
before the day after the gate's first real credit
(:func:`steam_backlog_enforcer._ledger_earners.first_credits`). The earners are read
**independently** -- :mod:`steam_backlog_enforcer._workout_budget`,
:mod:`steam_backlog_enforcer._leetcode_bonus`,
:mod:`steam_backlog_enforcer._reading_bonus` and, for any earner registered
later, :mod:`steam_backlog_enforcer._ledger_earners` share no state and none
can fail in a way that changes another's term. That is what "the LeetCode
bonus must not interfere with the workout" means in code.
**Fail closed.** An answer that could not be obtained contributes nothing, the
same as a "no". The difference is only in what gets reported: an unreadable
LeetCode ledger raises an incident, an honest "not solved yet" does not.
**Rising, and held there.** Every earner only ever goes false->true within a
day, so in the ordinary case the budget starts at the floor and rises. This
resolution alone does not guarantee it: earners reset at calendar midnight
while the gaming day runs to 05:59, and a cold restart resolves with empty
answer caches, so a live answer can come in lower than one given hours ago.
That bit twice (2026-10-03 and 2026-10-04 00:00, 8h -> 4h, unwarned cutoff).
``PlaytimeState.budget_seconds`` is the day's high-water mark, and
``rules_for`` applies ``max(resolved, held)`` via
``_gaming_days.held_today`` -- so the daemon, ``/api/budget`` and MCP all see
the held figure. Only the 06:00 roll-over lowers it.
**One seam.** :func:`resolve_budget` is called from ``rules_for`` and nowhere
else, so the enforcing daemon and the read-only HTTP/MCP views resolve the same
number. Callers that want the breakdown read it off ``PlaytimeRules``, never by
resolving a second time.
"""
from __future__ import annotations
from dataclasses import dataclass, field
from datetime import date, datetime
import logging
from typing import TYPE_CHECKING, Final
import earned_time
from steam_backlog_enforcer._gaming_days import gaming_day_key
from steam_backlog_enforcer._gaming_gate import gaming_enforced_on
from steam_backlog_enforcer._ledger_earners import (
first_credits,
ledger_answer,
ledger_units,
registry_for,
)
from steam_backlog_enforcer._leetcode_bonus import leetcode_solved_today
from steam_backlog_enforcer._reading_bonus import read_today
from steam_backlog_enforcer._workout_budget import workout_logged_today
if TYPE_CHECKING:
from steam_backlog_enforcer.config import Config
logger = logging.getLogger(__name__)
_SECONDS_PER_MINUTE: Final = 60.0
_SECONDS_PER_HOUR: Final = 3600.0
# The last reason logged, so a long-lived daemon logs a budget only on change.
_last_logged: Final[dict[str, str]] = {}
# Passed explicitly: ``leisure_active``'s default is bound at import, so this
# module constant is what a test redirects (as ``_leisure_mode`` does).
LEISURE_FROM_PATH: Final = earned_time.LEISURE_FROM_PATH
# How each earner reads in the reason string: (earned, missed, unknown).
# An earner registered later without an entry here gets a generic phrase.
_PHRASES: Final[dict[str, tuple[str, str, str]]] = {
"workout": (
"workout counted",
"no counted workout",
"workout unknown (screen-locker unreachable)",
),
"leetcode": (
"LeetCode solve recorded",
"no LeetCode solve recorded",
"LeetCode unknown (ledger and status API both unreadable)",
),
"reading": (
"reading credited",
"no reading credited",
"reading unknown (book-guard ledger unreadable)",
),
}
@dataclass(frozen=True)
class BudgetResolution:
"""Today's budget, and what earned it.
Attributes:
seconds: The budget to enforce.
base_seconds: The floor before any bonus.
workout_seconds: Seconds added by a counted workout, or 0.
leetcode_seconds: Seconds added by a LeetCode solve, or 0.
reason: A human-readable account, for the journal and ``/api/budget``.
reading_seconds: Seconds added by a credited reading session, or 0.
earned_seconds: Seconds added per earner name, every registered earner
included -- the generic form of the three fields above.
shadow_seconds: The same answers priced as leisure
(``earned_time.resolve(leisure=True)``, contract C4). Shown, never
enforced.
enforced: Whether any budget applies on this gaming day. ``False`` from
2026-11-16 (:mod:`_gaming_gate`): the numbers above are then
history, never a limit.
"""
seconds: float
base_seconds: float
workout_seconds: float
leetcode_seconds: float
reason: str
reading_seconds: float = 0.0
earned_seconds: dict[str, float] = field(default_factory=dict)
shadow_seconds: float = 0.0
enforced: bool = True
def _price(
answers: dict[str, int | bool | None],
today: date,
registry: tuple[earned_time.Earner, ...],
first_paid: dict[str, date | None] | None,
*,
leisure: bool,
) -> earned_time.Resolution:
"""Price one set of answers: ``leisure`` True = leisure, False = pre-leisure.
Always explicit (earned_time 0.16.0): ``False`` forces pre-leisure pricing,
it no longer means "by the switch file".
"""
if first_paid is None:
return earned_time.resolve(answers, today, registry, leisure=leisure)
return earned_time.resolve(
answers, today, registry, first_credits=first_paid, leisure=leisure
)
def _describe(name: str, label: str, answer: int | None) -> str:
"""Render one earner's answer (units, for a counted gate) for the reason."""
earned, missed, unknown = _PHRASES.get(
name, (f"{label} credited", f"no {label} credited", f"{label} unknown")
)
if answer is None:
return unknown
if not answer:
return missed
return earned if answer == 1 else f"{earned} x{answer}"
def _answers(
config: Config, registry: tuple[earned_time.Earner, ...]
) -> dict[str, int | bool | None]:
"""Every registered earner's answer for today, each read independently.
A counted gate (the Automation tutor) answers with its units today.
"""
answers: dict[str, int | bool | None] = {
"workout": workout_logged_today(config),
"leetcode": leetcode_solved_today(config),
"reading": read_today(config),
}
for earner in registry:
if earner.name not in answers:
answers[earner.name] = (
ledger_units(earner)
if earner.kind == "counted"
else ledger_answer(earner)
)
return answers
def leisure_priced(now: datetime) -> bool:
"""Whether the 06:00 gaming day holding *now* is priced as leisure.
The same question billing asks (``_leisure_mode.leisure_on`` of the billed
day), so 00:00-05:59 on the go-live date stays pre-leisure, like its bill.
"""
key = gaming_day_key(now)
day = date.fromisoformat(key)
return gaming_enforced_on(key) and bool(
earned_time.leisure_active(day, LEISURE_FROM_PATH)
)
def resolve_budget(config: Config) -> BudgetResolution:
"""Return today's gaming budget, and what earned it.
Args:
config: Loaded user configuration (for the earners' transports).
Returns:
The floor plus a bonus for each of today's earners. An answer that
could not be obtained contributes nothing, exactly as a "no" does --
the difference is only in what gets logged and reported.
"""
# The registry is passed explicitly: _answers iterated this same tuple, so
# the earners asked and the earners summed can never differ.
now = datetime.now().astimezone()
today = now.date()
registry = registry_for(today)
answers = _answers(config, registry)
# Maturity only delays a penalty: a gate that never paid out costs nothing.
first_paid = first_credits(registry, today)
day = _price(answers, today, registry, first_paid, leisure=leisure_priced(now))
# The same answers, asked once: the shadow can never see a different day.
# A missing answer was already warned about above; to earned_time it is
# the same as None, so spell it out rather than warn a second time.
complete = {e.name: None for e in registry} | answers
shadow = _price(complete, today, registry, first_paid, leisure=True)
earned = {t.earner.name: t.gaming_minutes * _SECONDS_PER_MINUTE for t in day.terms}
total = day.gaming_minutes * _SECONDS_PER_MINUTE
parts = ", ".join(
_describe(t.earner.name, t.earner.label, t.answer) for t in day.terms
)
enforced = gaming_enforced_on(gaming_day_key(now))
reason = f"{total / _SECONDS_PER_HOUR:.1f}h: {parts}"
if not enforced:
# Priced for history and the shadow only; no number may read as a limit.
reason = "unlimited (no gaming budget)"
# The daemon resolves every tick (3 s): an unchanged answer logged each
# time was 25k identical journal lines a day that buried everything else.
if reason != _last_logged.get("reason"):
_last_logged["reason"] = reason
logger.info("Gaming budget %s", reason)
return BudgetResolution(
seconds=total,
base_seconds=day.base.gaming_minutes * _SECONDS_PER_MINUTE,
workout_seconds=earned.get("workout", 0.0),
leetcode_seconds=earned.get("leetcode", 0.0),
reason=reason,
reading_seconds=earned.get("reading", 0.0),
earned_seconds=earned,
shadow_seconds=shadow.gaming_minutes * _SECONDS_PER_MINUTE,
enforced=enforced,
)