mirror of
https://github.com/kuhyx/steam-backlog-enforcer.git
synced 2026-11-21 15:12:21 +01:00
Each of these was one file doing several jobs, so they are split along what they actually do rather than at arbitrary line offsets: - _total_block: the lock file and the status derived from it stay in _total_block; making Steam *not installed* moves to _total_block_purge, making it *unreachable* to _total_block_hosts / _total_block_iptables. The generic pacman verbs (owner, installed, remove) become _pacman, since nothing about them is total-block-specific. Domain and process name tables become data modules. - _playtime: budget state and persistence (_playtime_state), pure transitions (_playtime_budget), cmdline process detection (_playtime_procs), the warn/cutoff/kill ladder (_playtime_cutoff), desktop notifications (_playtime_notify), process-tree walking and killing (_playtime_kill), mountinfo parsing (_playtime_mountinfo) and the shared privileged-command helper (_playtime_run). - _mcp: read-only tools (_mcp_query) split from mutating ones (_mcp_actions, _mcp_gaming_time), so "what can this server change?" is answerable from one file. _mcp keeps the server object and entry point. No re-export shims: callers import from the module that defines the name. That keeps a stale patch target loud (AttributeError) instead of letting it pass while intercepting nothing. `ruff check --select F821,F401` is run after every extraction -- an earlier mechanical attempt moved functions without the module-level names they referenced, which imported fine and only failed when called (349 errors), so it was reverted and redone by hand. The autouse fixtures in conftest are now imported by name and held by __all__; ruff --unsafe-fixes had deleted them as unused, since pytest resolves fixtures by name. 1324 tests pass at 100.00% coverage in the clean venv; `main status` is byte-identical to a worktree at HEAD. 49 -> 39 files over the cap. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01PPpmMpTSkp8UziRc5u8B7P
99 lines
3.0 KiB
Python
99 lines
3.0 KiB
Python
"""Pure state transitions for the daily playtime budget.
|
|
|
|
Separated from persistence: nothing here touches the disk or the clock
|
|
beyond what it is handed, which is what makes the budget arithmetic
|
|
straightforward to test.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from dataclasses import replace
|
|
import logging
|
|
from typing import TYPE_CHECKING
|
|
|
|
from steam_backlog_enforcer._playtime_state import (
|
|
_DELTA_CLAMP_FACTOR,
|
|
PlaytimeRules,
|
|
PlaytimeState,
|
|
)
|
|
|
|
if TYPE_CHECKING:
|
|
from datetime import datetime
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
def accumulate(
|
|
state: PlaytimeState,
|
|
*,
|
|
now: datetime,
|
|
qualifying: set[int],
|
|
interval: float,
|
|
) -> PlaytimeState:
|
|
"""Add this tick's elapsed gaming time to *state*.
|
|
|
|
Pure. Every argument is mandatory, including the clock — a defaulted ``now``
|
|
would add a branch that exists only to be covered.
|
|
|
|
The delta is clamped to ``_DELTA_CLAMP_FACTOR`` intervals so that a suspend,
|
|
a skipped tick or a forward NTP step cannot inflate the count, and floored
|
|
at zero so a backward step cannot refund time.
|
|
|
|
Args:
|
|
state: Current accounting state.
|
|
now: Timezone-aware local timestamp for this tick.
|
|
qualifying: PIDs currently counting against the budget.
|
|
interval: Nominal seconds between ticks.
|
|
|
|
Returns:
|
|
The updated state.
|
|
"""
|
|
stamp = now.timestamp()
|
|
if state.last_tick_at <= 0.0:
|
|
return replace(state, last_tick_at=stamp)
|
|
|
|
delta = stamp - state.last_tick_at
|
|
if delta <= 0.0 or not qualifying:
|
|
return replace(state, last_tick_at=stamp)
|
|
|
|
credited = min(delta, interval * _DELTA_CLAMP_FACTOR)
|
|
return replace(state, last_tick_at=stamp, seconds=state.seconds + credited)
|
|
|
|
|
|
def roll_over(state: PlaytimeState, *, day_key: str) -> PlaytimeState:
|
|
"""Reset *state* if the gaming day has changed.
|
|
|
|
Pure. ``last_tick_at`` carries across the boundary so the first tick of the
|
|
new day measures a sane delta rather than restarting from zero.
|
|
|
|
Args:
|
|
state: Current accounting state.
|
|
day_key: The gaming day *now* falls in.
|
|
|
|
Returns:
|
|
Either *state* unchanged, or a fresh record for *day_key*.
|
|
"""
|
|
if state.day_key == day_key:
|
|
return state
|
|
return PlaytimeState(day_key=day_key, last_tick_at=state.last_tick_at)
|
|
|
|
|
|
def pending_warning(state: PlaytimeState, rules: PlaytimeRules) -> int | None:
|
|
"""Return the largest un-fired warning threshold *state* has crossed.
|
|
|
|
Pure. Returning only the largest matters when a tick is skipped: crossing
|
|
two thresholds at once should warn once, not twice.
|
|
|
|
Args:
|
|
state: Current accounting state.
|
|
rules: Policy for this tick.
|
|
|
|
Returns:
|
|
The threshold in seconds-remaining, or ``None`` if none is due.
|
|
"""
|
|
remaining = rules.budget_seconds - state.seconds
|
|
for threshold in rules.warn_at:
|
|
if remaining <= threshold and threshold not in state.warned_seconds:
|
|
return threshold
|
|
return None
|