Datasets:
File size: 9,609 Bytes
cbf6b19 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 | """Checks of the task debug-off against the geany app's state, exported by REA from a desktop application capture.
It reads the app's data/get through the computer, takes the typed views of its files and evaluates each check: no
model, no code from the task. A failure to reach the app raises, so the run fails rather than scoring the agent.
"""
import json
import re
from agentenv_protocol import client as protocol
from agentenv_protocol.types import RPC_PATH
APP = "geany"
CHECKS = [
{"id": "changed", "kind": "lines_present", "file": "Documents/shop/settings.py", "lines": ["DEBUG = False", "PORT = 8080"]},
{"id": "old-gone", "kind": "lines_absent", "file": "Documents/shop/settings.py", "lines": ["DEBUG = True", "PORT = 8000"]},
{"id": "rest-kept", "kind": "lines_present", "file": "Documents/shop/settings.py", "lines": ["APP_NAME = \"Corner Shop\"", "HOST = \"127.0.0.1\"", "DATABASE_URL = \"sqlite:///shop.db\"", "ITEMS_PER_PAGE = 20", "CURRENCY = \"EUR\""]},
]
MISSING = object()
def _shown(value) -> str:
text = json.dumps(value, ensure_ascii=False, separators=(",", ":"))
return text if len(text) <= 200 else text[:200] + "…"
def _same(actual, expected) -> bool:
"""JSON equality: numbers by value but never a boolean for a number, objects by their keys, arrays in order."""
if isinstance(expected, list):
return (isinstance(actual, list) and len(actual) == len(expected)
and all(_same(item, wanted) for item, wanted in zip(actual, expected)))
if isinstance(expected, dict):
return (isinstance(actual, dict) and len(actual) == len(expected)
and all(key in actual and _same(actual[key], value) for key, value in expected.items()))
if isinstance(expected, bool) or isinstance(actual, bool):
return isinstance(expected, bool) and isinstance(actual, bool) and actual == expected
if isinstance(expected, (int, float)):
return isinstance(actual, (int, float)) and actual == expected
return type(actual) is type(expected) and actual == expected
def _resolve(view, pointer: str):
current = view
for raw in pointer[1:].split("/"):
token = raw.replace("~1", "/").replace("~0", "~")
if isinstance(current, list):
if not re.fullmatch(r"0|[1-9][0-9]*", token) or int(token) >= len(current):
return MISSING
current = current[int(token)]
elif isinstance(current, dict) and token in current:
current = current[token]
else:
return MISSING
return current
def _truncated(form, view) -> bool:
if not isinstance(view, dict):
return False
if form in ("text", "xml"):
return view.get("truncated") is True
if form != "sqlite":
return False
tables = view.get("tables")
return view.get("tables_truncated") is True or any(
isinstance(table, dict) and (table.get("truncated") is True or isinstance(table.get("error"), str))
for table in (tables.values() if isinstance(tables, dict) else []))
def _view_of(check, entry, form):
"""The view, whether it is truncated, and why the check cannot read it; an absent file reads as empty."""
if entry is None:
return None, False, None
if isinstance(entry.get("error"), str):
return None, False, f"{check['file']} has no view: {entry['error']}"
if entry.get("format") in (None, "binary"):
return None, False, f"{check['file']} is binary and has no view"
if form is not None and entry.get("format") != form:
return None, False, f"{check['file']} is read as {entry.get('format')}, not {form}"
return entry.get("view"), _truncated(entry.get("format"), entry.get("view")), None
def _undecided(check):
return False, f"the view of {check['file']} is truncated, so what it leaves out is unknown"
def _compared(check, n: int, what: str):
operator = next(key for key in ("equals", "at_least", "at_most") if check.get(key) is not None)
expected = check[operator]
met = n == expected if operator == "equals" else n >= expected if operator == "at_least" else n <= expected
return met, f"{n} {what}, expected {operator.replace('_', ' ')} {expected}"
def _lines(check, entry):
view, truncated, problem = _view_of(check, entry, "text")
if problem is not None:
return False, problem
lines = view.get("lines") if isinstance(view, dict) and isinstance(view.get("lines"), list) else []
lines = [line for line in lines if isinstance(line, str)]
file = check["file"]
if check["kind"] == "lines_present":
missing = next((line for line in check["lines"] if line not in lines), None)
return (True, f"{file} has the line(s) {_shown(check['lines'])}") if missing is None else (
False, f"{file} has no line {_shown(missing)}")
if truncated:
return _undecided(check)
if check["kind"] == "lines_absent":
found = next((line for line in check["lines"] if line in lines), None)
return (True, f"{file} has none of the lines {_shown(check['lines'])}") if found is None else (
False, f"{file} still has the line {_shown(found)}")
if check.get("contains") is not None:
n = sum(1 for line in lines if check["contains"] in line)
return _compared(check, n, f"line(s) of {file} contain {_shown(check['contains'])}")
n = sum(1 for line in lines if line == check["exact"])
return _compared(check, n, f"line(s) of {file} match {_shown(check['exact'])}")
def _value(check, entry):
view, truncated, problem = _view_of(check, entry, None)
if problem is not None:
return False, problem
found = MISSING if entry is None else _resolve(view, check["pointer"])
at = f"{check['file']} at {check['pointer']}"
if check["kind"] == "value_equals" and isinstance(check["value"], (dict, list)) and truncated:
return _undecided(check)
if check["kind"] == "value_equals":
if found is not MISSING and _same(found, check["value"]):
return True, f"{at} is {_shown(check['value'])}"
return False, f"{at} has no value" if found is MISSING else f"{at} is {_shown(found)}, not {_shown(check['value'])}"
if truncated:
return _undecided(check)
return (True, f"{at} has no value") if found is MISSING else (False, f"{at} is {_shown(found)}")
def _rows(check, entry):
view, _, problem = _view_of(check, entry, "sqlite")
if problem is not None:
return False, problem
view = view if isinstance(view, dict) else {}
tables = view.get("tables") if isinstance(view.get("tables"), dict) else {}
table = tables[check["table"]] if check["table"] in tables else MISSING
name = f"{check['file']} table {check['table']}"
if table is MISSING and view.get("tables_truncated") is True:
return _undecided(check)
table = table if isinstance(table, dict) else {}
if isinstance(table.get("error"), str):
return False, f"{name} could not be read: {table['error']}"
columns = table.get("columns") if isinstance(table.get("columns"), list) else []
rows = table.get("rows") if isinstance(table.get("rows"), list) else []
where = check.get("where") or {}
def matches(row) -> bool:
return isinstance(row, list) and all(
column in columns and columns.index(column) < len(row) and _same(row[columns.index(column)], value)
for column, value in where.items())
n = sum(1 for row in rows if matches(row))
if check["kind"] == "row_present":
return (n > 0, f"{name} has a row with {_shown(where)}" if n > 0 else f"{name} has no row with {_shown(where)}")
if table.get("truncated") is True:
return _undecided(check)
if check["kind"] == "row_absent":
return (True, f"{name} has no row with {_shown(where)}") if n == 0 else (
False, f"{name} has {n} row(s) with {_shown(where)}")
return _compared(check, n, f"row(s) of {name}" + (f" with {_shown(where)}" if "where" in check else ""))
def _verdict(check, entry):
kind = check["kind"]
if kind == "file_present":
return (entry is not None, f"{check['file']} exists" if entry is not None else f"{check['file']} does not exist")
if kind == "file_absent":
return (entry is None, f"{check['file']} does not exist" if entry is None else f"{check['file']} exists")
if kind in ("lines_present", "lines_absent", "line_count"):
return _lines(check, entry)
if kind in ("value_equals", "value_absent"):
return _value(check, entry)
return _rows(check, entry)
def evaluate(checks: list, views: dict) -> list:
"""One result per check against the views data/get returned, by home path."""
results = []
for check in checks:
passed, description = _verdict(check, views.get(check["file"]))
results.append({"id": check["id"], "result": passed, "description": description})
return results
async def verify(mcp_url, env_url):
card = await protocol.get_card(env_url)
child = protocol.find_child(card, APP)
if child is None:
raise RuntimeError(f"the computer at {env_url} lists no app named {APP}")
answer = await protocol.get_data(env_url + (child.get("url") or RPC_PATH).removesuffix(RPC_PATH), timeout=120)
states = [part.data["state"] for part in answer.parts
if part.kind == "data" and isinstance(part.data.get("state"), dict)]
if not states:
raise RuntimeError(f"the {APP} app's data/get returned no state views")
return evaluate(CHECKS, states[0])
|