mobster-cli 0.4.3__py3-none-any.whl

mobile_agent/android/manager.py

@@ -0,0 +1,225 @@
+"""The manager VerifyRun drives for an Android check: the simulator manager's interface over adb and one emulator or
+phone. One manager serves one run; its lease is the emulator manager's."""
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+from ..sim.models import AppInfo, SimError
+from . import adb as adb_module
+from .adb import Adb, AdbError
+from .conditions import AndroidConditions
+from .driver import AndroidDriver
+from .emulator import EmulatorManager
+
+# Android release -> API level, for `runtime: Android 16`.
+API_LEVELS = {"12": 31, "12L": 32, "13": 33, "14": 34, "15": 35, "16": 36}
+BADGING_PACKAGE = re.compile(r"package: name='([^']+)'[^\n]*?versionName='([^']*)'")
+BADGING_LABEL = re.compile(r"application-label:'([^']*)'")
+
+
+@dataclass(frozen=True)
+class AndroidRunTarget:
+    """What VerifyRun reads off a leased device. ``udid`` and the two addresses exist because the iOS side's log line
+    and report read them; Android has no WebDriverAgent."""
+    serial: str
+    name: str
+    kind: str
+    avd: str = ""
+    runtime: str = ""
+
+    @property
+    def udid(self):
+        return self.serial
+
+    @property
+    def device_type(self):
+        return self.avd or self.name
+
+    wda_url = ""
+    mjpeg_url = ""
+
+
+def _normal(text):
+    return re.sub(r"[^a-z0-9]", "", str(text).casefold())
+
+
+def avd_for(avds, device=None, runtime=None, api_of=lambda name: None):
+    """The AVD a check's ``device`` and ``runtime`` name: an exact name, else the first whose name starts with the
+    device, then the first on that Android release. None when nothing was asked for."""
+    chosen = list(avds)
+    if device:
+        wanted = _normal(device)
+        exact = [name for name in chosen if _normal(name) == wanted]
+        chosen = exact or [name for name in chosen if _normal(name).startswith(wanted)]
+    if runtime:
+        level = API_LEVELS.get(re.sub(r"(?i)^android\s*", "", runtime).strip())
+        if level is None:
+            raise SimError("environment", f"“{runtime}” is not an Android release Mobster knows "
+                                          f"({', '.join('Android ' + k for k in API_LEVELS)}).",
+                           "Name the release, such as runtime: Android 16.")
+        chosen = [name for name in chosen if api_of(name) == level]
+    if (device or runtime) and not chosen:
+        raise SimError("environment", f"No Android virtual device matches {device or ''} {runtime or ''}".strip() + ".",
+                       "`mobster sim android list` shows what exists; create one in Android Studio's Device Manager.")
+    return chosen[0] if (device or runtime) else None
+
+
+class AndroidManager:
+    # Fail closed: a manager is a phone's until it holds an emulator (verify.smart.is_real_device).
+    real_device = True
+    platform = "android"
+    system_prefixes = ("com.android.", "com.google.android.", "android")
+
+    def __init__(self, data_dir, *, name=None, emulators=None, adb_factory=None, phones=False):
+        self.emulators = emulators or EmulatorManager(data_dir)
+        self.name = name or ""   # an AVD name or an adb serial, from --android
+        # A check runs on an emulator only: Mobster can't yet tell someone's own builds from the apps on a phone. The
+        # device tools pass True; their own allowance decides which phone they may drive.
+        self.phones = phones
+        self._adb = adb_factory or (lambda serial: Adb(serial, self.emulators._run, self.emulators.adb.binary))
+
+    # -- the device
+
+    def _api_of(self, avd):
+        ini = Path.home() / ".android" / "avd" / f"{avd}.ini"
+        try:
+            match = re.search(r"target=android-(\d+)", ini.read_text())
+        except OSError:
+            return None
+        return int(match.group(1)) if match else None
+
+    def acquire(self, device=None, runtime=None, *, timeout=600, cancelled=None):
+        # A refusal here sends nothing, so the run's journal records it as rejected (verify/actions.py). ``cancelled``
+        # (the runner's stop flag) is read before a device is held; an emulator boot isn't interrupted.
+        from ..verify.actions import ActionNotDispatched
+        if cancelled is not None and cancelled():
+            raise ActionNotDispatched(SimError("environment", "The run was stopped before an Android device was held.",
+                                               ""))
+        serials = {row["serial"] for row in self.emulators.devices()}
+        serial = self.name if self.name in serials else None
+        avd = None if serial else (self.name or avd_for(self.emulators.avds(), device, runtime, self._api_of))
+        lease = self.emulators.acquire(avd=avd, serial=serial, timeout=timeout)
+        target = lease.target
+        if target.kind != "emulator" and not self.phones:
+            lease.release()
+            raise ActionNotDispatched(SimError(
+                "environment", f"“{target.name}” is an Android phone, and Mobster runs checks only on Android "
+                "emulators for now: it can't yet tell your own builds from the other apps on a phone.",
+                "Run the check on an emulator, such as mobster test --android Pixel_8."))
+        adb = self._adb(target.serial)
+        try:
+            release = adb.prop("ro.build.version.release")
+        except AdbError:
+            release = ""
+        lease.target = AndroidRunTarget(target.serial, target.name, target.kind, target.avd,
+                                        f"Android {release}" if release else "")
+        self.real_device = target.kind != "emulator"
+        self.adb = adb
+        return lease
+
+    def build_driver(self, target, run_dir, mode):
+        return AndroidDriver(target.serial, self._adb(target.serial))
+
+    def front_app(self, target):
+        return self._adb(target.serial).front_package() or None, None
+
+    def conditions(self, spec, target, bundle, actions=None):
+        return AndroidConditions(spec, self._adb(target.serial), bundle=bundle, emulator=target.kind == "emulator",
+                                 actions=actions)
+
+    # -- apps
+
+    def app_info(self, app_path):
+        path = Path(app_path)
+        if path.suffix.lower() != ".apk" or not path.is_file():
+            raise SimError("install", f"{app_path} is not an .apk file.", "Pass the .apk of the app the check names.")
+        aapt = adb_module.tool_in_build_tools("aapt2", self.emulators.root)
+        if aapt is None:
+            raise SimError("install", "Mobster can't read the package name of an .apk without aapt2.",
+                           "Install Android SDK Build-Tools from the SDK Manager, or name the app with bundle: and "
+                           "install it yourself.")
+        result = self.emulators._run([aapt, "dump", "badging", str(path)], 30, None)
+        text = result.text
+        match = BADGING_PACKAGE.search(text)
+        if result.code != 0 or not match:
+            raise SimError("install", f"aapt2 could not read {path.name}.", "Check that the file is a built APK.")
+        label = BADGING_LABEL.search(text)
+        return AppInfo(bundle_id=match.group(1), name=label.group(1) if label else match.group(1),
+                       version=match.group(2), path=str(path))
+
+    def installed_app(self, target, bundle_id):
+        try:
+            version = self._adb(target.serial).installed_version(bundle_id)
+        except AdbError as error:
+            raise SimError("install", str(error)) from None
+        if version is None:
+            raise SimError("install", f"{bundle_id} is not installed on {target.name}.",
+                           "Pass app.path with the .apk, or install the app first.")
+        return AppInfo(bundle_id=bundle_id, name=bundle_id, version=version, path=None)
+
+    def install(self, target, app_path):
+        info = self.app_info(app_path)
+        try:
+            self._adb(target.serial).install(app_path)
+        except AdbError as error:
+            raise SimError("install", str(error)) from None
+        return info
+
+    def reset(self, target, bundle_id, level, app_path=None):
+        if self.real_device and level != "none":
+            raise SimError("install", f"Mobster never clears or reinstalls an app on a phone, so it didn't reset "
+                           f"{bundle_id} ({level}).", "Use reset: none on a phone, or run the check on an emulator.")
+        adb = self._adb(target.serial)
+        try:
+            if level == "reinstall":
+                adb.uninstall(bundle_id)
+                adb.install(app_path)
+            elif level == "data":
+                adb.clear_data(bundle_id)
+            elif level != "none":
+                raise SimError("install", f"Mobster can't reset {bundle_id} at level {level!r} on Android.",
+                               "Use reset: none, data or reinstall.")
+        except AdbError as error:
+            raise SimError("install", str(error)) from None
+
+    def launch(self, target, bundle_id, args=(), env=None):
+        if args or env:
+            raise SimError("launch", "Launch arguments and environment aren't supported on Android.",
+                           "Remove launch.args and launch.env from the check.")
+        adb = self._adb(target.serial)
+        try:
+            adb.stop(bundle_id)
+            adb.launch(bundle_id)
+        except AdbError as error:
+            raise SimError("launch", str(error)) from None
+
+    def terminate(self, target, bundle_id):
+        try:
+            self._adb(target.serial).stop(bundle_id)
+        except AdbError as error:
+            raise SimError("launch", str(error)) from None
+
+    def open_url(self, target, url):
+        try:
+            self._adb(target.serial).open_url(url)
+        except AdbError as error:
+            raise SimError("launch", str(error)) from None
+
+    def screenshot(self, target, path, *, max_width=None, quality=75):
+        from io import BytesIO
+
+        from PIL import Image
+        path = Path(path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        try:
+            data = self._adb(target.serial).screenshot_png(30)
+        except AdbError as error:
+            raise SimError("simulator", f"The screenshot failed: {error}") from None
+        with Image.open(BytesIO(data)) as image:
+            image = image.convert("RGB")
+            if max_width and image.width > max_width:
+                image = image.resize((int(max_width), max(1, round(image.height * max_width / image.width))),
+                                     Image.LANCZOS)
+            image.save(path, "JPEG", quality=int(quality), optimize=True)
+        return path

mobile_agent/android/records.py

@@ -0,0 +1,31 @@
+"""Android devices as the device records `list_devices` and the device picker use (devices.discover's shape)."""
+
+from . import enabled
+
+
+def records(data_dir=None):
+    """One record per adb device, [] when Android is off or adb fails. ``emulator`` marks a device that is not
+    someone's phone: it is handled like an iOS simulator everywhere a record's kind is read."""
+    if not enabled():
+        return []
+    from ..paths import dev_data_dir
+    from .emulator import EmulatorManager
+    try:
+        rows = EmulatorManager(data_dir or dev_data_dir()).devices()
+    except Exception:
+        return []
+    out = []
+    for row in rows:
+        state = {"device": "ready", "offline": "disconnected",
+                 "unauthorized": "needs_setup"}.get(row["state"], "unknown")
+        out.append({"id": f"android:{row['serial']}", "kind": "android", "platform": "android", "name": row["name"],
+                    "model": row["name"], "serial": row["serial"], "avd": row["avd"] or None, "state": state,
+                    "emulator": row["kind"] == "emulator",
+                    "reason": "unlock the phone and accept the USB debugging prompt"
+                              if row["state"] == "unauthorized" else None})
+    return out
+
+
+def is_phone(record):
+    """Someone's own device: anything that is not an iOS simulator or an Android emulator."""
+    return record.get("kind") != "simulator" and not record.get("emulator")

mobile_agent/android/tree.py

@@ -0,0 +1,96 @@
+"""uiautomator's hierarchy as the XML the iOS side reads, so verify, replay and the agent need no Android branch.
+
+Roles take XCUIElementType names, resource-id becomes the identifier, text and content-desc the label, and frames are
+dp (pixels over density/160), so the point-based thresholds downstream mean the same thing on both platforms.
+"""
+
+import re
+from xml.etree import ElementTree as ET
+
+from ..state import _parse_wda
+
+BOUNDS = re.compile(r"\[(-?\d+),(-?\d+)\]\[(-?\d+),(-?\d+)\]")
+SYSTEM_UI = "com.android.systemui"
+# Longest class suffix first wins; an unknown class is "Other".
+ROLES = (
+    ("EditText", "TextField"), ("AutoCompleteTextView", "TextField"), ("SearchView", "SearchField"),
+    ("ImageButton", "Button"), ("Button", "Button"), ("Spinner", "Button"),
+    ("CheckBox", "Switch"), ("RadioButton", "Switch"), ("Switch", "Switch"), ("ToggleButton", "Switch"),
+    ("TextView", "StaticText"), ("ImageView", "Image"), ("SeekBar", "Slider"), ("ProgressBar", "ProgressIndicator"),
+    ("WebView", "WebView"), ("RecyclerView", "ScrollView"), ("ScrollView", "ScrollView"), ("ListView", "Table"),
+    ("GridView", "CollectionView"), ("TabWidget", "TabBar"), ("Toolbar", "Toolbar"),
+)
+TOGGLE_CLASSES = ("CheckBox", "RadioButton", "Switch", "ToggleButton")
+
+
+def role_of(cls, password=False):
+    if password:
+        return "SecureTextField"
+    short = (cls or "").rsplit(".", 1)[-1]
+    for suffix, role in ROLES:
+        if short.endswith(suffix):
+            return role
+    return "Other"
+
+
+def identifier(resource_id):
+    """"com.android.settings:id/search_action_bar" is "search_action_bar"."""
+    return (resource_id or "").rsplit("/", 1)[-1]
+
+
+def front_package(root):
+    """The package of the app in front: the first one that is not System UI, else System UI."""
+    packages = [node.get("package") for node in root.iter("node") if node.get("package")]
+    return next((name for name in packages if name != SYSTEM_UI), packages[0] if packages else "")
+
+
+def to_wda(xml, width_px, height_px, density):
+    """The hierarchy XML as WDA-shaped XML text. ``density`` is dpi; raises ValueError on an unusable tree."""
+    root = _parse_wda(xml)
+    if root.tag != "hierarchy":
+        raise ValueError("Not a uiautomator hierarchy")
+    scale = max(density, 1) / 160
+    out = ET.Element("XCUIElementTypeApplication", {
+        "type": "XCUIElementTypeApplication", "bundleId": front_package(root), "x": "0", "y": "0",
+        "width": _num(width_px / scale), "height": _num(height_px / scale)})
+    window = ET.SubElement(out, "XCUIElementTypeWindow", {"x": "0", "y": "0", "width": out.get("width"),
+                                                         "height": out.get("height")})
+    for child in root.findall("node"):
+        _convert(child, window, scale)
+    return ET.tostring(out, encoding="unicode")
+
+
+def _num(value):
+    return f"{value:.2f}".rstrip("0").rstrip(".")
+
+
+def _convert(node, parent, scale):
+    cls = node.get("class") or ""
+    password = node.get("password") == "true"
+    role = role_of(cls, password)
+    match = BOUNDS.fullmatch(node.get("bounds") or "")
+    left, top, right, bottom = (int(n) for n in match.groups()) if match else (0, 0, 0, 0)
+    text, desc = node.get("text") or "", node.get("content-desc") or ""
+    editable = role in {"TextField", "SecureTextField", "SearchField"}
+    toggle = cls.rsplit(".", 1)[-1].endswith(TOGGLE_CLASSES)
+    attrs = {"x": _num(left / scale), "y": _num(top / scale), "width": _num(max(right - left, 0) / scale),
+             "height": _num(max(bottom - top, 0) / scale),
+             "enabled": "true" if node.get("enabled") != "false" else "false"}
+    attrs["label"] = desc or ("" if editable else text)
+    # An unlabelled icon's id ("icon") would be read as its label, so only text-bearing nodes keep a bare id.
+    attrs["name"] = attrs["label"] if role == "Image" and not attrs["label"] else (
+        identifier(node.get("resource-id")) or attrs["label"])
+    if editable:
+        attrs["value"] = "" if password else text
+        if node.get("hint"):
+            attrs["placeholderValue"] = node.get("hint")
+    elif toggle:
+        attrs["value"] = "1" if node.get("checked") == "true" else "0"
+    traits = ["Selected"] if node.get("selected") == "true" or (toggle and node.get("checked") == "true") else []
+    if traits:
+        attrs["traits"] = ", ".join(traits)
+    if node.get("clickable") != "true" and role == "Other" and not attrs["label"]:
+        attrs["accessible"] = "false"
+    element = ET.SubElement(parent, f"XCUIElementType{role}", attrs)
+    for child in node.findall("node"):
+        _convert(child, element, scale)

mobile_agent/answer_shapes.py

@@ -0,0 +1,230 @@
+"""The model's answer as result blocks: the Markdown tables, check lines and dated event lines in a DONE answer become
+table, checklist and timeline blocks (``from_answer``), and the prompt line that asks for those shapes
+(``ANSWER_SHAPES``, ``wants_shapes``). This changes with the prompt and the models' output habits; the block schema and
+its one validation gate stay in ``result_blocks``.
+"""
+
+import re
+
+from .result_blocks import (
+    MAX_OPTIONS,
+    MAX_SERIES,
+    NUMERIC_COLUMNS,
+    STATUSES,
+    BlockError,
+    checklist,
+    status_word,
+    table,
+    timeline,
+    validate_block,
+)
+
+ANSWER_SHAPES = ("\n\nIn your DONE answer, start with one sentence that answers the request. When you checked or "
+                 "tested several screens or things, then write one line per check, - [pass] what you checked: what "
+                 "you saw (or [fail], [unsure]), and no table. Otherwise write several things that share the same "
+                 "details as a Markdown table (a header row, then one row each). For a chart or a graph, write its "
+                 "numbers as that table, labels or dates first: Mobster draws it. For places, give the table a Name "
+                 "and an Address column. Write events in time order as one line each, - <time or date>: what "
+                 "happened.")
+WANTS_SHAPES = re.compile(r"\b(list|lists|table|compare|comparison|each|every|all (?:my|the|of)|check|checks|test|go "
+                          r"through|rank|ranking|top \d+|which (?:ones|of)|summari[sz]e|breakdown|report|chart|graph|"
+                          r"plot|visuali[sz]e|trend|map|nearby|near me|timeline|itinerary|schedule|history|vs\.?|"
+                          r"versus)\b", re.I)
+CHART_WORDS = re.compile(r"\b(chart|graph|plot|visuali[sz]e|trend|trends|over time|histogram|pie|scatter)\b", re.I)
+PIE_WORDS = re.compile(r"\b(pie|donut|share|split|breakdown|proportion|percent of|makeup)\b", re.I)
+LINE_WORDS = re.compile(r"\b(line|trend|trends|over time|by (?:day|week|month|year)|daily|weekly|monthly|history)\b",
+                        re.I)
+SCATTER_WORDS = re.compile(r"\b(scatter|correlat\w*|relationship between)\b", re.I)
+COMPARE_WORDS = re.compile(r"\b(compare|comparison|vs\.?|versus|which (?:one |is )?(?:is )?better|pros and cons|"
+                           r"difference between|side by side)\b", re.I)
+MAP_WORDS = re.compile(r"\b(map|maps|near|nearby|near me|where|directions|around|closest|places)\b", re.I)
+ADDRESS_LABELS = re.compile(r"^(address|location|where|place|street|addr\.?)$", re.I)
+LAT_LABELS = re.compile(r"^(lat|latitude)$", re.I)
+LON_LABELS = re.compile(r"^(lon|lng|long|longitude)$", re.I)
+
+
+def wants_shapes(request):
+    """Whether the stable prompt asks this request's answer for tables and check lines."""
+    return bool(WANTS_SHAPES.search(str(request or "")))
+
+
+_ROW = re.compile(r"^\s*\|(.+)\|\s*$")
+_RULE = re.compile(r"^\s*\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)*\|?\s*$")
+_CHECK = re.compile(r"^\s*[-*]\s*(?:\[(pass|passed|ok|fail|failed|unsure|uncertain|unknown)\]|(✅|❌|⚠️?))\s*(.+?)\s*$",
+                    re.I)
+_HEADING = re.compile(r"^\s*#{1,4}\s+(.+?)\s*#*\s*$")
+_NUMBER = re.compile(r"^[-+]?[$€£¥]?\s?\d[\d,]*(\.\d+)?\s?(%|[kKmM])?$")
+_DATE = re.compile(r"^\d{4}-\d{2}-\d{2}([T ]\d{2}:\d{2}(:\d{2})?)?$")
+
+
+def _split_row(line):
+    cells, current, escaped = [], "", False
+    for char in _ROW.match(line).group(1):
+        if escaped:
+            current += char
+            escaped = False
+        elif char == "\\":
+            escaped = True
+        elif char == "|":
+            cells.append(current.strip())
+            current = ""
+        else:
+            current += char
+    cells.append(current.strip())
+    return [re.sub(r"^\*\*(.*)\*\*$", r"\1", cell) for cell in cells]
+
+
+def _column_type(values):
+    values = [value for value in values if value]
+    if not values:
+        return "text"
+    if all(_NUMBER.match(value) for value in values):
+        if all("%" in value for value in values):
+            return "percent"
+        if any(symbol in value for value in values for symbol in "$€£¥"):
+            return "money"
+        return "number" if not any(value[-1:] in "kKmM" for value in values) else "text"
+    if all(_DATE.match(value) for value in values):
+        return "date"
+    if all(value.startswith("https://") and " " not in value for value in values):
+        return "link"
+    if all(status_word(value) in STATUSES for value in values):
+        return "status"
+    return "text"
+
+
+def _title_before(lines, index):
+    """A heading or a line ending in ":" right above ``index`` (blank lines between allowed): (title, its index)."""
+    at = index - 1
+    while at >= 0 and not lines[at].strip():
+        at -= 1
+    if at < 0:
+        return None, None
+    heading = _HEADING.match(lines[at])
+    text = heading.group(1) if heading else lines[at].strip()[:-1] if lines[at].strip().endswith(":") and len(
+        lines[at].strip()) <= 120 and not lines[at].lstrip().startswith(("-", "*", "|")) else None
+    return (text.strip("* ") or None, at) if text else (None, None)
+
+
+_WHEN = (r"(?:\d{1,2}(?::\d{2})?\s?(?:[AaPp]\.?[Mm]\.?)|\d{1,2}:\d{2}|\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2})?|"
+         r"(?:Mon|Tue|Tues|Wed|Thu|Thur|Thurs|Fri|Sat|Sun)[a-z]*\.?(?:,? \d{1,2}(?::\d{2})?\s?(?:[AaPp][Mm])?)?|"
+         r"(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Sept|Oct|Nov|Dec)[a-z]*\.? \d{1,2}(?:, \d{4})?|"
+         r"(?:Day|Week) \d{1,3}|(?:19|20)\d{2}|Today|Tonight|Tomorrow|Yesterday|Morning|Noon|Afternoon|Evening)")
+_EVENT = re.compile(r"^\s*[-*]\s+(?:\*\*)?(" + _WHEN + r"(?:\s?[-–]\s?" + _WHEN + r")?)"
+                    r"(?:\*\*)?\s*(?::|—|–| - )\s*(.+?)\s*$")
+
+
+def _event(line):
+    """(at, title, detail) of a "- 9:00 AM: Boarded the train. Seat 14" line, or None."""
+    match = _EVENT.match(line)
+    if not match:
+        return None
+    text = match.group(2).strip()
+    title, _, detail = text.partition(". ")
+    if len(title) > 120:
+        title, detail = text[:117].rstrip() + "…", text
+    return match.group(1), title.strip("* ").rstrip("."), detail.strip() or None
+
+
+def _table_view(block, request):
+    """The view a table opens in, from what the request asked: its chart, its map or its options side by side."""
+    columns, rows = block["columns"], block["rows"]
+    words = str(request or "")
+    labels = [c["label"].strip() for c in columns]
+    numeric = [c for c in columns if c.get("type") in NUMERIC_COLUMNS]
+    if (any(ADDRESS_LABELS.match(l) for l in labels) or (any(LAT_LABELS.match(l) for l in labels)
+                                                         and any(LON_LABELS.match(l) for l in labels))) \
+            and MAP_WORDS.search(words):
+        block["view"] = "map"
+        return block
+    if CHART_WORDS.search(words) and numeric and len(rows) >= 2:
+        first = next((c for c in columns if c not in numeric), None)
+        if SCATTER_WORDS.search(words) and len(numeric) >= 2:
+            chart = {"kind": "scatter", "x": numeric[0]["key"], "y": [numeric[1]["key"]]}
+        else:
+            if PIE_WORDS.search(words) and len(rows) <= 8 and all(
+                    isinstance(r["cells"].get(numeric[0]["key"]), (int, float)) and r["cells"][numeric[0]["key"]] >= 0
+                    for r in rows):
+                kind = "pie"
+            elif (first is not None and first.get("type") == "date") or LINE_WORDS.search(words):
+                kind = "area" if re.search(r"\barea\b", words, re.I) else "line"
+            else:
+                kind = "bar"
+            chart = {"kind": kind, "y": [c["key"] for c in numeric][:1 if kind == "pie" else MAX_SERIES]}
+            if first is not None:
+                chart["x"] = first["key"]
+        block["chart"], block["view"] = chart, "chart"
+        return block
+    if COMPARE_WORDS.search(words) and 2 <= len(rows) <= MAX_OPTIONS and len(columns) >= 3:
+        block["view"] = "compare"
+    return block
+
+
+def from_answer(text, request=None):
+    if not isinstance(text, str):
+        return text, []
+    lines, blocks, drop, index = text.split("\n"), [], set(), 0
+    while index < len(lines):
+        if _ROW.match(lines[index]) and index + 1 < len(lines) and _RULE.match(lines[index + 1]):
+            end = index + 2
+            while end < len(lines) and _ROW.match(lines[end]):
+                end += 1
+            header, body = _split_row(lines[index]), [_split_row(line) for line in lines[index + 2:end]]
+            if body and len(header) >= 2:
+                width = len(header)
+                body = [(row + [""] * width)[:width] for row in body]
+                kinds = [_column_type([row[i] for row in body]) for i in range(width)]
+                title, at = _title_before(lines, index)
+                columns = [{"label": label or f"Column {i + 1}", "type": kinds[i]} for i, label in enumerate(header)]
+                try:
+                    shaped = validate_block(table(columns, body, title=title, id=f"t{len(blocks) + 1}"))
+                except BlockError:  # a table a block can't hold (17+ columns) stays in the answer as text
+                    index = end
+                    continue
+                blocks.append((index, _table_view(shaped, request) if request else shaped))
+                drop.update(range(index, end))
+                if at is not None:
+                    drop.add(at)
+                index = end
+                continue
+        if _event(lines[index]):
+            end = index
+            while end < len(lines) and _event(lines[end]):
+                end += 1
+            if end - index >= 3:
+                items = []
+                for line in lines[index:end]:
+                    at, title, detail = _event(line)
+                    items.append({"at": at, "title": title, "detail": detail})
+                title, at = _title_before(lines, index)
+                blocks.append((index, timeline(items, title=title, id=f"e{len(blocks) + 1}")))
+                drop.update(range(index, end))
+                if at is not None:
+                    drop.add(at)
+                index = end
+                continue
+        if _CHECK.match(lines[index]):
+            end = index
+            while end < len(lines) and _CHECK.match(lines[end]):
+                end += 1
+            if end - index >= 2:
+                items = []
+                for line in lines[index:end]:
+                    match = _CHECK.match(line)
+                    word = (match.group(1) or {"✅": "pass", "❌": "fail"}.get(match.group(2), "uncertain")).lower()
+                    label, _, observed = match.group(3).partition(": ")
+                    items.append({"label": label.strip("* ") or match.group(3), "status": status_word(word),
+                                  "observed": observed.strip() or None})
+                title, at = _title_before(lines, index)
+                blocks.append((index, checklist(items, title=title, id=f"c{len(blocks) + 1}")))
+                drop.update(range(index, end))
+                if at is not None:
+                    drop.add(at)
+                index = end
+                continue
+        index += 1
+    if not blocks:
+        return text, []
+    rest = "\n".join(line for i, line in enumerate(lines) if i not in drop)
+    rest = re.sub(r"\n{3,}", "\n\n", rest).strip()
+    return rest, [block for _, block in sorted(blocks, key=lambda pair: pair[0])]