| """Checks of the task fix-section-heading against the lyx 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. It grades once the app's files settle, since an app can save a few seconds after the |
| last change: each result's settled says whether they had held for SETTLE_WINDOW_S, or had not by SETTLE_BOUND_S and |
| the last completed read was graded, and read_cut whether a read still running at SETTLE_BOUND_S was cut. A failure to |
| reach the app raises, so the run fails rather than scoring the agent. |
| """ |
| import asyncio |
| import hashlib |
| import json |
| import math |
| import re |
| import time |
|
|
| from agentenv_protocol import client as protocol |
| from agentenv_protocol.types import RPC_PATH |
|
|
| APP = "lyx" |
| CHECKS = [ |
| {"id": "heading-fixed", "kind": "lines_present", "file": "Documents/garden-report.lyx", "lines": ["Soil Preparation"]}, |
| {"id": "typo-gone", "kind": "lines_absent", "file": "Documents/garden-report.lyx", "lines": ["Soil Preperation"]}, |
| {"id": "three-sections", "kind": "line_count", "file": "Documents/garden-report.lyx", "exact": "\\begin_layout Section", "equals": 3}, |
| {"id": "other-headings-kept", "kind": "lines_present", "file": "Documents/garden-report.lyx", "lines": ["Introduction", "Harvest Results"]}, |
| ] |
| |
| SETTLE_INTERVAL_S = 0.5 |
| |
| SETTLE_WINDOW_S = 3.0 |
| |
| |
| SETTLE_BOUND_S = 15.0 |
| |
| DATA_OBJECTS = "urn:agentenv:data-objects/v1" |
|
|
| MISSING = object() |
| INDEX = re.compile(r"0|[1-9][0-9]*") |
| VIEW_FORMATS = ("text", "json", "keyfile", "xml") |
| NUMERAL = re.compile(r"[+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[eE][+-]?[0-9]+)?") |
| WHITESPACE_RUN = re.compile(r"[ \t\r\n]+") |
|
|
|
|
| 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 _is_element(value) -> bool: |
| return (isinstance(value, dict) and isinstance(value.get("name"), str) and isinstance(value.get("attributes"), dict) |
| and isinstance(value.get("children"), list)) |
|
|
|
|
| def _element_text(element, attribute=None) -> str: |
| """An element's text as XPath's string() reads it from what the view keeps: every text node among its children |
| and its descendants', in document order. With attribute, the values of that attribute on it and its descendants |
| instead, in document order, and no text node.""" |
| parts, pending = [], [element] |
| while pending: |
| node = pending.pop() |
| if isinstance(node, str): |
| if attribute is None: |
| parts.append(node) |
| elif _is_element(node): |
| if attribute is not None and isinstance(node["attributes"].get(attribute), str): |
| parts.append(node["attributes"][attribute]) |
| pending.extend(reversed(node["children"])) |
| return "".join(parts) |
|
|
|
|
| def _bracketed(token: str) -> bool: |
| return len(token) >= 2 and token.startswith("[") and token.endswith("]") |
|
|
|
|
| def _selector(token: str): |
| """A selector's conditions, [KEY=VALUE], [@KEY=VALUE] or [>KEY=VALUE] one or more times, or None when the token |
| is not one.""" |
| if not _bracketed(token): |
| return None |
| conditions = [] |
| for part in token[1:-1].split("]["): |
| key, equals, value = part.partition("=") |
| prefix = key[:1] if key[:1] in ("@", ">") else "" |
| name = key[len(prefix):] |
| if not equals or not name: |
| return None |
| conditions.append((prefix, name, value)) |
| return conditions |
|
|
|
|
| def _has_child_text(member, key: str, value: str) -> bool: |
| """Whether an element has a child element named key whose text, its whitespace collapsed, is value.""" |
| return _is_element(member) and any( |
| _is_element(child) and child["name"] == key and _collapse_whitespace(_element_text(child)) == value |
| for child in member["children"]) |
|
|
|
|
| def _selects(member, conditions) -> bool: |
| """Whether an array member meets every condition; selectors compare strings only.""" |
| if not isinstance(member, dict): |
| return False |
| for prefix, key, value in conditions: |
| if prefix == ">": |
| if not _has_child_text(member, key, value): |
| return False |
| continue |
| fields = member.get("attributes") if prefix == "@" else member |
| if not isinstance(fields, dict) or not isinstance(fields.get(key), str) or fields[key] != value: |
| return False |
| return True |
|
|
|
|
| def _step(items: list, token: str, last: bool): |
| """One step into an array, by index or by a selector that must match one member, or none when it is the last.""" |
| if INDEX.fullmatch(token): |
| return ("member", items[int(token)]) if int(token) < len(items) else ("none", None) |
| conditions = _selector(token) |
| if conditions is None: |
| return ("unresolved", f"{token} is not a selector of the form [KEY=VALUE]") if _bracketed(token) else ( |
| "none", None) |
| matched = [item for item in items if _selects(item, conditions)] |
| if len(matched) == 1: |
| return "member", matched[0] |
| if len(matched) > 1: |
| return "unresolved", f"{token} matches {len(matched)} members, not one" |
| return ("none" if last else "unresolved"), f"{token} matches no member" |
|
|
|
|
| def _locate(view, pointer: str): |
| """Where a pointer leads: ("value", value), ("none", why or None) or ("unresolved", problem), with the pointers |
| to the arrays a selector searched on the way.""" |
| current, searched = view, [] |
| segments = pointer[1:].split("/") |
| for position, segment in enumerate(segments): |
| token = segment.replace("~1", "/").replace("~0", "~") |
| if isinstance(current, list): |
| if not INDEX.fullmatch(token) and _selector(token) is not None: |
| searched.append("".join("/" + part for part in segments[:position])) |
| kind, found = _step(current, token, position == len(segments) - 1) |
| if kind != "member": |
| return kind, found, searched |
| current = found |
| elif isinstance(current, dict) and token in current: |
| current = current[token] |
| else: |
| return "none", None, searched |
| return "value", current, searched |
|
|
|
|
| def _number(value): |
| """A number, or a numeral string read as one; None for anything else, a boolean, or a numeral past the doubles.""" |
| if isinstance(value, bool): |
| return None |
| if isinstance(value, (int, float)): |
| return value |
| if not isinstance(value, str) or not NUMERAL.fullmatch(value): |
| return None |
| number = float(value) |
| return number if math.isfinite(number) else None |
|
|
|
|
| def _entry_leaves_out(entry) -> bool: |
| return isinstance(entry, dict) and (isinstance(entry.get("view_error"), str) or ( |
| entry.get("format") in ("text", "xml") and isinstance(entry.get("view"), dict) |
| and entry["view"].get("truncated") is True)) |
|
|
|
|
| def _viewless_entry(view, pointer: str): |
| """The name of the entry whose view a pointer goes into when it has none, so its null is no JSON value, and |
| why: binary, unread, or of a format without a view; None when it has one.""" |
| parts = pointer[1:].split("/") |
| if len(parts) < 3 or parts[0] != "entries" or parts[2] != "view": |
| return None |
| kind, item, _ = _locate(view, "/entries/" + parts[1]) |
| if kind != "value" or not isinstance(item, dict): |
| return None |
| if isinstance(item.get("view_error"), str): |
| reason = f"has no view: {item['view_error']}" |
| elif item.get("format") == "binary": |
| reason = "is binary and has no view" |
| elif item.get("format") not in VIEW_FORMATS: |
| reason = "has no view" |
| else: |
| return None |
| return (item["name"] if isinstance(item.get("name"), str) else ""), reason |
|
|
|
|
| def _array_leaves_out(form, view, array: str) -> bool: |
| """Whether an array a selector searched may lack members: in a zip the listing or its entry's view, else the |
| view's own truncation.""" |
| if form != "zip": |
| return _truncated(form, view) |
| if array == "/entries": |
| return isinstance(view, dict) and view.get("truncated") is True |
| return _zip_leaves_out(view, array) |
|
|
|
|
| def _zip_leaves_out(view, pointer: str) -> bool: |
| """Whether a zip view leaves out what a pointer reaches: for a pointer into one listed entry, only that entry.""" |
| if not isinstance(view, dict): |
| return False |
| parts = pointer[1:].split("/") |
| if parts[0] == "entries" and len(parts) > 1: |
| kind, entry, _ = _locate(view, "/entries/" + parts[1]) |
| return _entry_leaves_out(entry) if kind == "value" else view.get("truncated") is True |
| entries = view.get("entries") if isinstance(view.get("entries"), list) else [] |
| return view.get("truncated") is True or any(_entry_leaves_out(entry) for entry in entries) |
|
|
|
|
| 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 _near(at: str, found, expected, tolerance): |
| """A value compared within a tolerance: numbers, and numeral strings, by their difference.""" |
| number = _number(found) |
| within = f"within {_shown(tolerance)} of {_shown(expected)}" |
| if number is None: |
| return False, f"{at} is {_shown(found)}, not a number" |
| if abs(number - expected) <= tolerance: |
| return True, f"{at} is {_shown(found)}, {within}" |
| return False, f"{at} is {_shown(found)}, not {within}" |
|
|
|
|
| def _value(check, entry): |
| view, truncated, problem = _view_of(check, entry, None) |
| if problem is not None: |
| return False, problem |
| kind, found, searched = ("none", None, []) if entry is None else _locate(view, check["pointer"]) |
| at = f"{check['file']} at {check['pointer']}" |
| viewless = _viewless_entry(view, check["pointer"]) if entry is not None and entry.get("format") == "zip" else None |
| if viewless is not None: |
| return False, f"{check['file']} entry {viewless[0]} {viewless[1]}" |
| |
| if any(_array_leaves_out(entry.get("format"), view, array) for array in searched): |
| return _undecided(check) |
| if kind == "unresolved": |
| return False, f"{at}: {found}" |
| if entry is not None and entry.get("format") == "zip": |
| truncated = _zip_leaves_out(view, check["pointer"]) |
| if check["kind"] == "value_equals" and isinstance(check["value"], (dict, list)) and truncated: |
| return _undecided(check) |
| if check["kind"] == "value_equals": |
| if kind == "none": |
| return False, f"{at} has no value" if found is None else f"{at}: {found}" |
| expected = check["value"] |
| if check.get("tolerance") is not None and isinstance(expected, (int, float)) and not isinstance(expected, bool): |
| return _near(at, found, expected, check["tolerance"]) |
| if _same(found, check["value"]): |
| return True, f"{at} is {_shown(check['value'])}" |
| return False, f"{at} is {_shown(found)}, not {_shown(check['value'])}" |
| if truncated: |
| return _undecided(check) |
| return (True, f"{at} has no value") if kind == "none" else (False, f"{at} is {_shown(found)}") |
|
|
|
|
| def _collapse_whitespace(text: str) -> str: |
| """Each run of XML whitespace (space, tab, CR, LF) made one space, none at either end, as normalize-space().""" |
| return WHITESPACE_RUN.sub(" ", text).strip(" ") |
|
|
|
|
| def _text_at(view, pointer: str) -> bool: |
| """Whether a string a pointer reaches is text of the document: a member of an element's children (a text node) |
| or attributes (an attribute's value), rather than an element's name or a field of the DOCTYPE.""" |
| segments = pointer.split("/") |
| if len(segments) < 3 or segments[-2] not in ("children", "attributes"): |
| return False |
| kind, owner, _ = _locate(view, "/".join(segments[:-2])) |
| return kind == "value" and _is_element(owner) |
|
|
|
|
| def _not_xml_entry(check, view): |
| """Why a text check's pointer into an archive goes into no XML entry's view, or None when it does or names an |
| entry not listed.""" |
| parts = check["pointer"].split("/") |
| if len(parts) < 4 or parts[3] != "view": |
| return f"{check['file']} at {check['pointer']} does not point into an entry's view" |
| if parts[1] != "entries": |
| return None |
| kind, item, _ = _locate(view, "/entries/" + parts[2]) |
| if kind != "value" or not isinstance(item, dict) or item.get("format") == "xml": |
| return None |
| |
| name, form = (value if isinstance(value, str) else "" for value in (item.get("name"), item.get("format"))) |
| return f"{check['file']} entry {name} is read as {form}, not xml" |
|
|
|
|
| def _whole_text(check, entry): |
| """An element's whole text, or a text node's, compared with the value or searched for it.""" |
| view, truncated, problem = _view_of(check, entry, None) |
| if problem is not None: |
| return False, problem |
| at = f"{check['file']} at {check['pointer']}" |
| if entry is None: |
| return False, f"{at} has no value" |
| form = entry.get("format") |
| if form not in ("xml", "zip"): |
| return False, f"{check['file']} is read as {form}, not xml" |
| kind, found, searched = _locate(view, check["pointer"]) |
| viewless = _viewless_entry(view, check["pointer"]) if form == "zip" else None |
| if viewless is not None: |
| return False, f"{check['file']} entry {viewless[0]} {viewless[1]}" |
| if any(_array_leaves_out(form, view, array) for array in searched): |
| return _undecided(check) |
| problem = _not_xml_entry(check, view) if form == "zip" else None |
| if problem is not None: |
| return False, problem |
| if kind == "unresolved": |
| return False, f"{at}: {found}" |
| if kind == "none": |
| return False, f"{at} has no value" if found is None else f"{at}: {found}" |
| |
| attribute = check.get("text_attribute") |
| if not ((attribute is None and _text_at(view, check["pointer"])) if isinstance(found, str) else _is_element(found)): |
| what = "an element, a text node or an attribute value" if attribute is None else "an element" |
| return False, f"{at} is {_shown(found)}, not {what}" |
| |
| if form == "zip": |
| truncated = _zip_leaves_out(view, check["pointer"]) |
| if not isinstance(found, str) and truncated: |
| return _undecided(check) |
| return _compared_text(check, at, _element_text(found, attribute)) |
|
|
|
|
| def _compared_text(check, at: str, found: str): |
| """A text found at a pointer compared with the check's value or searched for it, both collapsed when it asks.""" |
| collapse = check.get("normalize_whitespace") is True |
| text = _collapse_whitespace(found) if collapse else found |
| value = _collapse_whitespace(check["value"]) if collapse else check["value"] |
| attribute = check.get("text_attribute") |
| read = "" if attribute is None else f" in its {attribute} values" |
| how = read + (" with whitespace collapsed" if collapse else "") |
| if check["kind"] == "text_equals": |
| if text == value: |
| return True, f"{at} has the text {_shown(value)}{how}" |
| return False, f"{at} has the text {_shown(text)}{how}, not {_shown(value)}" |
| if value in text: |
| return True, f"{at} has text containing {_shown(value)}{how}" |
| return False, f"{at} has the text {_shown(text)}{how}, without {_shown(value)}" |
|
|
|
|
| def _members(check, entry): |
| """How many members of the array at a pointer, or of those a selector matches, compared with the expected |
| number.""" |
| matching, pointer = check.get("matching"), check["pointer"] |
| view, truncated, problem = _view_of(check, entry, None) |
| if problem is not None: |
| return False, problem |
| form = None if entry is None else entry.get("format") |
| |
| kind, found, searched = (("none", None, []) if entry is None else ("value", view, []) if pointer == "" |
| else _locate(view, pointer)) |
| at = check["file"] if pointer == "" else f"{check['file']} at {pointer}" |
| viewless = _viewless_entry(view, pointer) if form == "zip" else None |
| if viewless is not None: |
| return False, f"{check['file']} entry {viewless[0]} {viewless[1]}" |
| if any(_array_leaves_out(form, view, array) for array in searched): |
| return _undecided(check) |
| if kind == "unresolved": |
| return False, f"{at}: {found}" |
| if kind == "none": |
| return False, f"{at} has no value" if found is None else f"{at}: {found}" |
| if not isinstance(found, list): |
| return False, f"{at} is {_shown(found)}, not an array" |
| |
| if _array_leaves_out(form, view, pointer): |
| return _undecided(check) |
| |
| conditions = None if matching is None else _selector(matching) |
| n = len(found) if matching is None else sum(1 for item in found if conditions and _selects(item, conditions)) |
| return _compared(check, n, f"member(s) of {at}" + ("" if matching is None else f" matching {matching}")) |
|
|
|
|
| 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) |
| if kind in ("text_equals", "text_contains"): |
| return _whole_text(check, entry) |
| if kind == "member_count": |
| return _members(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 |
|
|
|
|
| def _files(answer) -> list: |
| """Each file data/get returned, by its home path or its place among the parts, with the SHA-256 of its bytes as |
| sent: what changes when the app saves.""" |
| files = [] |
| for index, part in enumerate(answer.parts): |
| if part.kind != "file": |
| continue |
| marker = (getattr(part, "metadata", None) or {}).get(DATA_OBJECTS) |
| path = marker.get("path") if isinstance(marker, dict) else None |
| content = getattr(part.file, "bytes", None) or getattr(part.file, "uri", None) or "" |
| files.append((path if isinstance(path, str) else f"#{index}", hashlib.sha256(content.encode()).hexdigest())) |
| return sorted(files) |
|
|
|
|
| async def _read(url): |
| answer = await protocol.get_data(url, 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 states[0], _files(answer) |
|
|
|
|
| async def _settled_views(url): |
| """The app's views once each file's bytes have held for SETTLE_WINDOW_S, counted from the read that returned them, |
| read every SETTLE_INTERVAL_S; else the last completed read's. No read starts SETTLE_BOUND_S or more after the first |
| began, and one still running then is cut. Also whether the files had held, and whether a read was cut.""" |
| start = time.monotonic() |
| |
| views, files = await _read(url) |
| |
| |
| began, since = 0.0, time.monotonic() - start |
| while began - since < SETTLE_WINDOW_S: |
| |
| at = max(min(began + SETTLE_INTERVAL_S, since + SETTLE_WINDOW_S), time.monotonic() - start) |
| if at >= SETTLE_BOUND_S: |
| return views, False, False |
| await asyncio.sleep(max(0.0, at - (time.monotonic() - start))) |
| at = max(at, time.monotonic() - start) |
| if at >= SETTLE_BOUND_S: |
| return views, False, False |
| try: |
| latest_views, latest = await asyncio.wait_for(_read(url), SETTLE_BOUND_S - at) |
| except asyncio.TimeoutError: |
| return views, False, True |
| began, views = at, latest_views |
| if latest != files: |
| since, files = time.monotonic() - start, latest |
| return views, True, False |
|
|
|
|
| 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}") |
| views, settled, read_cut = await _settled_views(env_url + (child.get("url") or RPC_PATH).removesuffix(RPC_PATH)) |
| return [{**result, "settled": settled, "read_cut": read_cut} for result in evaluate(CHECKS, views)] |
|
|
