6885bbee3d
Standalone CLI that diffs two engine-surface snapshots across all four axes,
the foundation the FastAPI/DB layer will sit on.
- ams.snapshot : typed access to a snapshot.json
- ams.diff : keyed set-diff per axis (added/removed/changed) + cross-owner
method-move detection; types keyed by (script_name,
via_module_iface) so the dual MULTIARRAY stays stable;
filter_by_owner for per-class focus
- ams.render : human-readable report (+/-/~), owner-grouped
- ams.cli : python -m ams OLD NEW [--owner C] [--only ...] [--json]
6 tests pass, incl. an integration test over the committed golden pair
(asserts BlooMoo adds GRBUFFER/INTERNET, MOUSE grows 104->128, Animo gains
GETFPS, Animo script fields unchanged).
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
121 lines
5.2 KiB
Python
121 lines
5.2 KiB
Python
"""Human-readable rendering of a snapshot diff (see diff.compute_diff)."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from typing import Any, Callable
|
|
|
|
|
|
def _counts(block: dict[str, Any]) -> str:
|
|
return "+{0} -{1} ~{2}".format(
|
|
len(block["added"]), len(block["removed"]), len(block["changed"]))
|
|
|
|
|
|
def _fmt_changes(changes: dict[str, list]) -> str:
|
|
return "; ".join("{0}: {1} -> {2}".format(f, v[0], v[1]) for f, v in sorted(changes.items()))
|
|
|
|
|
|
def _group_by(items: list[dict], owner_of: Callable[[dict], str]) -> dict[str, list[dict]]:
|
|
out: dict[str, list[dict]] = {}
|
|
for it in items:
|
|
out.setdefault(owner_of(it) or "?", []).append(it)
|
|
return out
|
|
|
|
|
|
# --- per-axis item formatting ------------------------------------------------------------------
|
|
def _fmt_type(t: dict) -> str:
|
|
tag = " [via module iface]" if t.get("via_module_iface") else ""
|
|
size = t.get("object_size")
|
|
cls = t.get("cpp_class") or "?"
|
|
return "{0} -> {1} (size {2}){3}".format(t["script_name"], cls, size, tag)
|
|
|
|
|
|
def _fmt_method(m: dict) -> str:
|
|
return "{0} (id {1})".format(m["name"], m.get("id"))
|
|
|
|
|
|
def _fmt_event(e: dict) -> str:
|
|
return "{0} (#{1})".format(e["name"], e.get("order"))
|
|
|
|
|
|
def _fmt_field(f: dict) -> str:
|
|
return "{0}: {1}".format(f["name"], f.get("type"))
|
|
|
|
|
|
def _fmt_layout(x: dict) -> str:
|
|
vt = " vtable" if x.get("is_vtable") else ""
|
|
return "@{0:#x} size {1}{2}".format(x["offset"], x.get("size"), vt)
|
|
|
|
|
|
# --- section renderers -------------------------------------------------------------------------
|
|
def _section_flat(out: list[str], title: str, block: dict, fmt: Callable[[dict], str],
|
|
name_of: Callable[[dict], str]) -> None:
|
|
out.append("")
|
|
out.append("{0:<16} {1}".format(title, _counts(block)))
|
|
for it in sorted(block["added"], key=name_of):
|
|
out.append(" + {0}".format(fmt(it)))
|
|
for it in sorted(block["removed"], key=name_of):
|
|
out.append(" - {0}".format(name_of(it)))
|
|
for ch in sorted(block["changed"], key=lambda c: name_of(c["item"])):
|
|
out.append(" ~ {0:<22} {1}".format(name_of(ch["item"]), _fmt_changes(ch["changes"])))
|
|
|
|
|
|
def _section_owned(out: list[str], title: str, block: dict, fmt: Callable[[dict], str],
|
|
owner_of: Callable[[dict], str], name_of: Callable[[dict], str]) -> None:
|
|
out.append("")
|
|
out.append("{0:<16} {1}".format(title, _counts(block)))
|
|
added = _group_by(block["added"], owner_of)
|
|
removed = _group_by(block["removed"], owner_of)
|
|
changed = _group_by([c["item"] for c in block["changed"]], owner_of)
|
|
change_by_id = {id(c["item"]): c for c in block["changed"]}
|
|
for owner in sorted(set(added) | set(removed) | set(changed)):
|
|
out.append(" {0}".format(owner))
|
|
for it in sorted(added.get(owner, []), key=name_of):
|
|
out.append(" + {0}".format(fmt(it)))
|
|
for it in sorted(removed.get(owner, []), key=name_of):
|
|
out.append(" - {0}".format(name_of(it)))
|
|
for it in sorted(changed.get(owner, []), key=name_of):
|
|
out.append(" ~ {0:<22} {1}".format(
|
|
name_of(it), _fmt_changes(change_by_id[id(it)]["changes"])))
|
|
|
|
|
|
def _is_empty(block: dict) -> bool:
|
|
return not (block["added"] or block["removed"] or block["changed"])
|
|
|
|
|
|
def render_text(diff: dict[str, Any], only: set[str] | None = None) -> str:
|
|
b = diff["binary"]
|
|
out: list[str] = ["Engine surface diff"]
|
|
out.append(" from: {0} [{1}/{2}]".format(
|
|
b["from"].get("name", "?"), b["from"].get("engine", "?"), b["from"].get("compiler", "?")))
|
|
out.append(" to: {0} [{1}/{2}]".format(
|
|
b["to"].get("name", "?"), b["to"].get("engine", "?"), b["to"].get("compiler", "?")))
|
|
|
|
def want(axis: str) -> bool:
|
|
return only is None or axis in only
|
|
|
|
if want("types") and not _is_empty(diff["types"]):
|
|
_section_flat(out, "TYPES", diff["types"], _fmt_type, lambda t: t["script_name"])
|
|
if want("methods") and not _is_empty(diff["methods"]):
|
|
_section_owned(out, "METHODS", diff["methods"], _fmt_method,
|
|
lambda m: m["owner"], lambda m: m["name"])
|
|
if want("events") and not _is_empty(diff["events"]):
|
|
_section_owned(out, "EVENTS", diff["events"], _fmt_event,
|
|
lambda e: e["owner"], lambda e: e["name"])
|
|
if want("fields") and not _is_empty(diff["fields"]):
|
|
_section_owned(out, "FIELDS", diff["fields"], _fmt_field,
|
|
lambda f: f["owner"], lambda f: f["name"])
|
|
if want("layout") and not _is_empty(diff["struct_layout"]):
|
|
_section_owned(out, "STRUCT LAYOUT", diff["struct_layout"], _fmt_layout,
|
|
lambda x: x["owner"], lambda x: "@{0:#x}".format(x["offset"]))
|
|
if want("methods") and diff["moved_methods"]:
|
|
out.append("")
|
|
out.append("MOVED METHODS {0}".format(len(diff["moved_methods"])))
|
|
for m in sorted(diff["moved_methods"], key=lambda x: x["name"]):
|
|
out.append(" {0}: {1} -> {2}".format(
|
|
m["name"], ",".join(m["from_owners"]), ",".join(m["to_owners"])))
|
|
|
|
if all(_is_empty(diff[a]) for a in ("types", "methods", "events", "fields", "struct_layout")):
|
|
out.append("")
|
|
out.append("(no differences)")
|
|
return "\n".join(out)
|