steam-backlog-enforcer/steam_installer/compat_rows.py
Krzysztof kuhy Rudnicki 94a0e8a1c3 Add map-installed Proton map view and apply job
GET /api/compat serves every installed game's compat-tool decision as
rows from the installer's own code (steam_installer/compat_rows.py, the
rows --map-installed now logs from), cached by file stats. The Library
page gets a Proton map view (sortable, filterable, fuzzy search, hash
state, 30 s poll) and a map-installed job: POST checks the ids, the
phrase "map N games" and the game-running guard; the job re-checks
them and streams --map-installed --apply --yes --appids.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01WzxdWZCxnNWLtpVwFLVk9w
2026-11-22 21:43:23 +01:00

150 lines
5.0 KiB
Python

"""What ``--map-installed --apply`` would do, one structured row per game.
``map_installed.run`` logs from these rows and the enforcer's web view serves
them (``GET /api/compat``), so the two can never disagree and nothing ever
parses the log. ``changes`` uses the same :func:`compat_map.keep_reason` that
:func:`compat_map.map_app` uses, so a row says "changes" exactly when apply
would rewrite that game's entry.
"""
from __future__ import annotations
from dataclasses import asdict, dataclass
from typing import TYPE_CHECKING, Any
from steam_installer import appinfo, compat_apply, compat_map, recognize
from steam_installer.library import SteamLibrary, list_libraries
if TYPE_CHECKING:
from pathlib import Path
# Steam's own compat tools and runtimes are apps too, but not games.
TOOL_TYPES = {"tool", "config"}
NOT_CACHED = "not in Steam's app cache"
@dataclass(frozen=True)
class Row:
"""One game's compat decision.
Attributes:
current: The tool config.vdf maps it to; None = unmapped (Valve's default).
priority: That mapping's priority, None when unmapped.
decided: The tool after apply; None = Valve's default.
reasons: Why the decision keeps Valve's default (empty = map it).
note: Why apply leaves an entry the decision would map ("already
mapped", or kuhy's own tool "kept: ...").
map: The decision's verdict.
changes: Whether apply would rewrite this game's entry.
cached: Whether Steam's app cache knows the game at all.
"""
appid: int
name: str
current: str | None
priority: str | None
decided: str | None
reasons: tuple[str, ...]
note: str | None
map: bool
changes: bool
cached: bool
def to_json(self) -> dict[str, object]:
"""The web contract's ``CompatRow``."""
data = asdict(self)
data["app_id"] = data.pop("appid")
data["reasons"] = list(self.reasons)
return data
def installed(libraries: list[SteamLibrary]) -> dict[int, dict[str, Any]]:
"""Appid -> AppState for every manifest in every library."""
found: dict[int, dict[str, Any]] = {}
for library in libraries:
for manifest in sorted(library.steamapps.glob("appmanifest_*.acf")):
appid = manifest.stem.removeprefix("appmanifest_")
if appid.isdigit():
found[int(appid)] = recognize.read_app_state(manifest)
return found
def owned_dlc(app_state: dict[str, Any]) -> bool:
"""Whether the manifest lists an owned DLC depot."""
depots = app_state.get("InstalledDepots")
entries = depots.values() if isinstance(depots, dict) else []
return any(isinstance(entry, dict) and "dlcappid" in entry for entry in entries)
def is_tool(block: dict[str, Any]) -> bool:
"""Whether the app is one of Steam's tools or runtimes, not a game."""
common = block.get("common")
kind = common.get("type", "") if isinstance(common, dict) else ""
return isinstance(kind, str) and kind.lower() in TOOL_TYPES
def _row(
context: compat_apply.Context,
appid: int,
block: dict[str, Any] | None,
app_state: dict[str, Any],
) -> Row:
entry = compat_map.current(context.config, appid)
current = (entry[0] or None) if entry else None
priority = (entry[1] or None) if entry else None
if block is None:
name = app_state.get("name", "")
return Row(
appid=appid,
name=name if isinstance(name, str) else "",
current=current,
priority=priority,
decided=current,
reasons=(NOT_CACHED,),
note=None,
map=False,
changes=False,
cached=False,
)
decision = context.decide(appid, block, owned_dlc=owned_dlc(app_state))
held = compat_map.keep_reason(entry) if decision.map else None
changes = decision.map and held is None
note = None
if held is not None:
note = "already mapped" if held.action == "already" else f"kept: {held.detail}"
common = block.get("common")
name = common.get("name", "?") if isinstance(common, dict) else "?"
return Row(
appid=appid,
name=str(name),
current=current,
priority=priority,
decided=compat_map.TOOL if changes else current,
reasons=tuple(decision.reasons),
note=note,
map=decision.map,
changes=changes,
cached=True,
)
def rows(
steam_root: Path,
appids: list[int] | None = None,
context: compat_apply.Context | None = None,
) -> list[Row]:
"""Rows for every installed game, or for exactly *appids* (tools included).
Raises:
appinfo.AppInfoError: Steam's app cache cannot be read.
"""
context = context or compat_apply.Context(steam_root)
states = installed(list_libraries(steam_root))
ids = appids if appids is not None else sorted(states)
blocks = appinfo.cached_blocks(ids)
return [
_row(context, appid, blocks.get(appid), states.get(appid, {}))
for appid in ids
if appids is not None or appid not in blocks or not is_tool(blocks[appid])
]