lean-browser-use 0.0.0-stage → 0.1.0

package/reader/reader_extract.py

@@ -0,0 +1,261 @@
+"""Public page reader: extract operations."""
+from reader_base import *
+from reader_crawl import crawl_helper
+
+class PageParser(HTMLParser):
+    def __init__(self):
+        super().__init__(convert_charrefs=False)
+        self.scripts = []
+        self.script = None
+        self.trimmed = []
+        self.skip = 0
+
+    def handle_starttag(self, tag, attrs):
+        if tag == "script":
+            self.script = [dict(attrs), ""]
+        if tag in ("script", "style", "svg"):
+            self.skip += 1
+        if not self.skip:
+            self.trimmed.append(self.get_starttag_text())
+
+    def handle_endtag(self, tag):
+        if tag == "script" and self.script is not None:
+            self.scripts.append(self.script)
+            self.script = None
+        if tag in ("script", "style", "svg") and self.skip:
+            self.skip -= 1
+        elif not self.skip:
+            self.trimmed.append(f"</{tag}>")
+
+    def handle_data(self, data):
+        if self.script is not None:
+            self.script[1] += data
+        if not self.skip:
+            self.trimmed.append(data)
+
+    def handle_entityref(self, name):
+        self.handle_data(f"&{name};")
+
+    def handle_charref(self, name):
+        self.handle_data(f"&#{name};")
+
+
+def page_data(html):
+    parser = PageParser()
+    parser.feed(html)
+    embedded = {}
+    decoder = json.JSONDecoder()
+    for attrs, content in parser.scripts:
+        if attrs.get("type", "").lower() in ("application/json", "application/ld+json") or attrs.get("id") == "__NEXT_DATA__":
+            try:
+                value = json.loads(content)
+                key = attrs.get("id") or f"ld+json:{len(embedded)}"
+                embedded[key] = value
+            except ValueError:
+                pass
+        for match in re.finditer(r"(?:window\s*\.\s*)?(__[\w$]+)\s*=\s*", content):
+            tail = content[match.end():].lstrip()
+            try:
+                if tail.startswith("JSON.parse("):
+                    encoded, _ = decoder.raw_decode(tail[len("JSON.parse("):].lstrip())
+                    value = json.loads(encoded)
+                else:
+                    value, _ = decoder.raw_decode(tail)
+                if isinstance(value, (dict, list)):
+                    embedded[match.group(1)] = value
+            except (ValueError, TypeError):
+                pass
+    return embedded, "".join(parser.trimmed)
+
+
+def path_get(value, path):
+    if path in ("", ".", "$"):
+        return value
+    # A backslash escapes dots in object keys, for example dist-tags.latest.
+    parts = re.split(r"(?<!\\)\.", path.removeprefix("$."))
+    try:
+        for part in parts:
+            part = part.replace("\\.", ".").replace("\\\\", "\\")
+            value = value[int(part)] if isinstance(value, list) else value[part]
+        return value
+    except (KeyError, IndexError, TypeError, ValueError):
+        return None
+
+
+def normalize(rows, transforms):
+    for row in rows:
+        if not isinstance(row, dict):
+            continue
+        for key, transform in transforms.items():
+            value = row.get(key)
+            if value is None:
+                continue
+            if isinstance(transform, str):
+                transform = {"number": transform == "number"}
+            if transform.get("regex"):
+                match = re.search(transform["regex"], str(value))
+                value = match.group(transform.get("group", 1)) if match else None
+            if value is not None and transform.get("number"):
+                try:
+                    value = float(str(value).replace(",", "").strip())
+                    if not math.isfinite(value):
+                        value = None
+                    elif value.is_integer():
+                        value = int(value)
+                except ValueError:
+                    value = None
+            row[key] = value
+    return rows
+
+
+def extract(spec, html):
+    if spec["type"] == "embedded_json":
+        embedded, _ = page_data(html)
+        source = embedded.get(spec["source"])
+        data = path_get(source, spec.get("rows", "."))
+        if data is None:
+            return []
+        data = data if isinstance(data, list) else [data]
+        rows = [{key: path_get(row, path) for key, path in spec["paths"].items()} for row in data]
+    else:
+        rows = crawl_helper("css", {"html": html, "schema": spec["schema"]}, 12).get("rows")
+    if not isinstance(rows, list):
+        raise ReaderError(12, "extraction failed: expected list rows")
+    return normalize(rows, spec.get("transforms", {}))
+
+
+def empty(value):
+    return value is None or value == "" or value == [] or value == {} or (isinstance(value, str) and not value.strip())
+
+
+def failures(spec, rows):
+    if not rows:
+        return ["list rows >= 1", *spec["required"]]
+    example = spec.get("example")
+    if isinstance(example, list):
+        example = example[0] if example else {}
+    example = example or {}
+    keys = set(spec["required"]) | set(example or {})
+    missing = []
+    for index, row in enumerate(rows):
+        if not isinstance(row, dict):
+            missing.append(f"row[{index}] must be an object")
+            continue
+        for key in sorted(keys):
+            if key not in row or (key in spec["required"] and empty(row[key])):
+                missing.append(f"row[{index}].{key}")
+            elif row[key] is not None and isinstance(example.get(key), (int, float)) and not isinstance(example[key], bool):
+                if isinstance(row[key], bool) or not isinstance(row[key], (int, float)) or not math.isfinite(row[key]):
+                    missing.append(f"row[{index}].{key} must be numeric")
+        example_keys = sorted(example)
+        for offset, key in enumerate(example_keys):
+            for other in example_keys[offset + 1:]:
+                if (isinstance(row.get(key), str) and len(row[key]) >= 3 and not empty(row[key])
+                        and isinstance(row.get(other), str) and len(row[other]) >= 3 and not empty(row[other])
+                        and example[key] != example[other]
+                        and row[key] == row[other]):
+                    missing.append(f"row[{index}].{key} equals {other}; example values differ")
+    return missing
+
+
+def anchor_failures(example, rows):
+    if example is None:
+        return []
+    if isinstance(example, list):
+        example = example[0]
+
+    def matches(value, expected):
+        if isinstance(value, str) and isinstance(expected, str):
+            return " ".join(value.split()) == " ".join(expected.split())
+        if (isinstance(value, (int, float)) and not isinstance(value, bool)
+                and isinstance(expected, (int, float)) and not isinstance(expected, bool)):
+            return value == expected
+        return type(value) is type(expected) and value == expected
+
+    nearest, best = {}, -1
+    for row in rows:
+        if not isinstance(row, dict):
+            continue
+        score = sum(key in row and matches(row[key], value) for key, value in example.items())
+        if score == len(example):
+            return []
+        if score > best:
+            nearest, best = row, score
+    return ["example row not found; nearest row: " + json.dumps(nearest, ensure_ascii=False)]
+
+
+def validate_candidate(candidate, example):
+    if example is not None and not (isinstance(example, dict) or
+            isinstance(example, list) and example and all(isinstance(row, dict) for row in example)):
+        raise ValueError("example must be an object or non-empty list of objects")
+    if not isinstance(candidate, dict) or candidate.get("type") not in ("embedded_json", "css"):
+        raise ValueError("schema needs type embedded_json or css")
+    if candidate["type"] == "embedded_json":
+        if not isinstance(candidate.get("source"), str) or not isinstance(candidate.get("paths"), dict) or not candidate["paths"]:
+            raise ValueError("embedded_json needs source and non-empty paths")
+        if not all(isinstance(p, str) for p in candidate["paths"].values()) or not isinstance(candidate.get("rows", "."), str):
+            raise ValueError("paths and rows must be dotted strings")
+        keys = list(candidate["paths"])
+    else:
+        schema = candidate.get("schema")
+        if not isinstance(schema, dict) or not schema.get("baseSelector") or not isinstance(schema.get("fields"), list) or not schema["fields"]:
+            raise ValueError("css needs schema with baseSelector and fields")
+        for field in schema["fields"]:
+            if not isinstance(field, dict) or not isinstance(field.get("name"), str) or field.get("type") not in ("text", "attribute", "regex", "html"):
+                raise ValueError("CSS fields must use text, attribute, regex, or html")
+            if any(key in field for key in ("expression", "function", "default")):
+                raise ValueError("CSS fields cannot use computed values or defaults")
+        keys = [field["name"] for field in schema["fields"]]
+    required = candidate.setdefault("required", keys)
+    if not isinstance(required, list) or not required or not all(isinstance(key, str) and key in keys for key in required):
+        raise ValueError("required must be a non-empty list of output field names")
+    if not isinstance(candidate.get("transforms", {}), dict):
+        raise ValueError("transforms must be an object")
+    for key, transform in candidate.get("transforms", {}).items():
+        if key not in keys:
+            raise ValueError(f"transform field {key} is absent from output")
+        if isinstance(transform, str):
+            if transform != "number":
+                raise ValueError("string transform must be number")
+            continue
+        if not isinstance(transform, dict) or set(transform) - {"regex", "group", "number"}:
+            raise ValueError("transform must use regex, group and/or number")
+        if "number" in transform and not isinstance(transform["number"], bool):
+            raise ValueError("transform number must be boolean")
+        if "regex" in transform:
+            if not isinstance(transform["regex"], str):
+                raise ValueError("transform regex must be a string")
+            try:
+                pattern = re.compile(transform["regex"])
+            except re.error as exc:
+                raise ValueError(f"invalid transform regex: {exc}") from exc
+            group = transform.get("group", 1)
+            if not isinstance(group, int) or isinstance(group, bool) or not 0 <= group <= pattern.groups:
+                raise ValueError("transform group must name an existing numeric capture group")
+        elif "group" in transform:
+            raise ValueError("transform group needs a regex")
+    # The compile command supplies extraction rules only, never stored metadata.
+    allowed = ("type", "source", "rows", "paths", "schema", "required", "transforms")
+    return {key: value for key, value in candidate.items() if key in allowed}
+
+
+def failing_row_samples(spec, rows, errors, html):
+    indices = list(dict.fromkeys(int(match) for error in errors
+                   for match in re.findall(r"row\[(\d+)\]", error)))[:3]
+    indices = [index for index in indices if index < len(rows)]
+    markup = {}
+    if indices and spec["type"] == "css":
+        try:
+            markup = crawl_helper("css", {"html": html, "schema": spec["schema"],
+                                  "sample_indices": indices}, 12).get("samples", {})
+        except ReaderError:
+            pass
+    elif indices:
+        for match in re.finditer(r"<script\b[^>]*>.*?</script\s*>", html, re.DOTALL | re.IGNORECASE):
+            if spec["source"] in page_data(match.group())[0]:
+                markup = {str(index): match.group()[:600] for index in indices}
+                break
+    return [{"index": index, "values": json.dumps(rows[index], ensure_ascii=False)[:600],
+             "outer_html": markup.get(str(index), "")[:600]} for index in indices]
+
+

package/reader/reader_fetch.py

@@ -0,0 +1,148 @@
+"""Public page reader: fetch operations."""
+from reader_base import *
+from reader_crawl import crawl_helper
+
+def checked_address(url):
+    if not isinstance(url, str) or any(c.isspace() or ord(c) < 32 for c in url):
+        raise ReaderError(2, "refused target: whitespace or control character")
+    try:
+        target = urlsplit(url)
+        if target.scheme not in ("http", "https") or not target.hostname:
+            raise ValueError("only http(s) URLs with a host are supported")
+        if target.username is not None or target.password is not None:
+            raise ValueError("URL credentials are not supported")
+        port = target.port or (443 if target.scheme == "https" else 80)
+    except ValueError as exc:
+        raise ReaderError(2, f"refused target: {exc}") from exc
+    try:
+        addresses = socket.getaddrinfo(target.hostname, port, type=socket.SOCK_STREAM,
+                                       proto=socket.IPPROTO_TCP)
+    except OSError as exc:
+        raise ReaderError(10, f"fetch failed: DNS lookup: {exc}") from exc
+    if not addresses:
+        raise ReaderError(10, "fetch failed: DNS returned no addresses")
+    for address in addresses:
+        ip = ipaddress.ip_address(address[4][0].split("%", 1)[0])
+        # Tests may opt in to one exact local HTTP origin, never a host range.
+        if (target.scheme == "http" and target.hostname == "127.0.0.1" and target.port
+                and os.environ.get("READER_TEST_ALLOW_ORIGIN") == f"http://127.0.0.1:{port}"
+                and str(ip) == "127.0.0.1"):
+            continue
+        if not ip.is_global or ip.is_multicast or ip.is_reserved:
+            raise ReaderError(2, f"refused target: {target.hostname} resolves to a non-public address")
+    return addresses[0]
+
+
+def connection(cls, host, address, **kwargs):
+    conn = cls(host, **kwargs)
+
+    def connect(unused, timeout, source_address=None):
+        sock = socket.socket(address[0], address[1], address[2])
+        try:
+            sock.settimeout(timeout)
+            sock.connect(address[4])
+            return sock
+        except BaseException:
+            sock.close()
+            raise
+
+    conn._create_connection = connect
+    return conn
+
+
+class PinnedHTTP(HTTPHandler):
+    def http_open(self, req):
+        return self.do_open(lambda host, **kw: connection(
+            http.client.HTTPConnection, host, req.checked_address, **kw), req)
+
+
+class PinnedHTTPS(HTTPSHandler):
+    def https_open(self, req):
+        return self.do_open(lambda host, **kw: connection(
+            http.client.HTTPSConnection, host, req.checked_address, **kw), req,
+            context=self._context)
+
+
+class PublicRedirect(HTTPRedirectHandler):
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        address = checked_address(newurl)
+        redirected = super().redirect_request(req, fp, code, msg, headers, newurl)
+        if redirected:
+            redirected.checked_address = address
+        return redirected
+
+    def http_error_302(self, req, fp, code, msg, headers):
+        # urllib drains redirect bodies before following them. Bound that drain.
+        if len(fp.read(FETCH_CAP + 1)) > FETCH_CAP:
+            fp.close()
+            raise ReaderError(10, "fetch failed: redirect body exceeds size limit")
+        return super().http_error_302(req, fp, code, msg, headers)
+
+    http_error_301 = http_error_303 = http_error_307 = http_error_308 = http_error_302
+
+
+def fetch_urllib(url):
+    req = Request(url, headers={"User-Agent": USER_AGENT, "Accept-Encoding": "identity"})
+    req.checked_address = checked_address(url)
+    # Disable ambient proxies so the checked sockaddr is the actual destination.
+    opener = build_opener(ProxyHandler({}), PinnedHTTP(), PinnedHTTPS(), PublicRedirect())
+    try:
+        with opener.open(req, timeout=30) as response:
+            body = response.read(FETCH_CAP + 1)
+            if len(body) > FETCH_CAP:
+                raise ReaderError(10, "fetch failed: page exceeds size limit")
+            try:
+                return body.decode(response.headers.get_content_charset() or "utf-8", errors="replace")
+            except LookupError:
+                return body.decode("utf-8", errors="replace")
+    except HTTPError:
+        raise
+    except (OSError, URLError, ValueError) as exc:
+        raise ReaderError(10, f"fetch failed: {exc}") from exc
+
+
+def bot_wall(html):
+    title = re.search(r"<title\b[^>]*>(.*?)</title>", html, re.DOTALL | re.IGNORECASE)
+    if title and re.search(r"just a moment|attention required|access denied|verify (?:you are|you're) human|captcha",
+                           title.group(1), re.IGNORECASE):
+        return True
+    return bool(re.search(r"/cdn-cgi/challenge-platform/[^\s\"'<>]*orchestrate/|\bcf-chl-|_cf_chl_opt\b|please enable js and disable any ad blocker",
+                          html, re.IGNORECASE))
+
+
+def fetch_crwl(url):
+    checked_address(url)
+    page = crawl_helper("fetch", {"url": url}, 10)
+    try:
+        if page.get("success") is False or (page.get("status_code") or 200) >= 400:
+            raise ValueError("returned an unsuccessful page")
+        for key in ("url", "redirected_url"):
+            if page.get(key):
+                checked_address(page[key])
+        html = page.get("html")
+        if not isinstance(html, str) or not html.strip():
+            raise ValueError("returned no html field")
+        if len(html.encode("utf-8")) > FETCH_CAP:
+            raise ValueError("page exceeds size limit")
+        if bot_wall(html):
+            raise ValueError("page is still a bot wall")
+        return html
+    except (ValueError, TypeError) as exc:
+        raise ReaderError(10, f"fetch failed: crwl helper: {exc}") from exc
+
+
+def fetch(url, preferred="urllib"):
+    if preferred == "crwl":
+        return fetch_crwl(url), "crwl"
+    try:
+        html = fetch_urllib(url)
+    except HTTPError as exc:
+        exc.close()
+        if exc.code not in (401, 403, 429):
+            raise ReaderError(10, f"fetch failed: {exc}") from exc
+        return fetch_crwl(url), "crwl"
+    if bot_wall(html):
+        return fetch_crwl(url), "crwl"
+    return html, "urllib"
+
+

package/reader/reader_runtime.py

@@ -0,0 +1,199 @@
+"""Public page reader: runtime operations."""
+from reader_base import *
+from reader_fetch import fetch
+from reader_extract import extract, failures, validate_candidate
+from reader_compile import compile_spec, required_compile_command
+
+def spec_path(name):
+    if not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9_-]{0,99}", name):
+        raise ReaderError(2, "name must use letters, digits, underscores or hyphens")
+    directory = Path(os.environ.get("READER_SPECS_DIR", ROOT / "specs"))
+    return directory / f"{name}.json"
+
+
+def state_dir():
+    return Path(os.environ.get("READER_STATE_DIR", Path.home() / ".cache/lean-browser-use/reader"))
+
+
+def state_path(name):
+    return state_dir() / spec_path(name).name
+
+
+def override_path(name):
+    return state_dir() / "specs" / spec_path(name).name
+
+
+def selected_path(name):
+    override = override_path(name)
+    return override if override.exists() else spec_path(name)
+
+
+def save_json(path, value):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with tempfile.NamedTemporaryFile(mode="w", dir=path.parent, prefix=f".{path.stem}.", suffix=".tmp", delete=False) as stream:
+        temp = Path(stream.name)
+        try:
+            json.dump(value, stream, indent=2, ensure_ascii=False, allow_nan=False)
+            stream.write("\n")
+            stream.close()
+            os.replace(temp, path)
+        finally:
+            temp.unlink(missing_ok=True)
+
+
+def save(spec, runtime=False):
+    name = spec["name"]
+    save_json(override_path(name) if runtime else spec_path(name), spec)
+    if not runtime:
+        # An explicit compile replaces any older healed rules and run metadata.
+        override_path(name).unlink(missing_ok=True)
+        state_path(name).unlink(missing_ok=True)
+
+
+def save_state(spec, html, fetch_method):
+    save_json(state_path(spec["name"]), {
+        "last_ok": now(), "healed_at": spec.get("healed_at"),
+        "fetch_method": fetch_method, "page_hash": page_hash(html),
+    })
+
+
+def load(name):
+    try:
+        spec = json.loads(selected_path(name).read_text())
+        if not isinstance(spec, dict):
+            raise ValueError("spec must be a JSON object")
+        if state_path(name).exists():
+            state = json.loads(state_path(name).read_text())
+            if not isinstance(state, dict):
+                raise ValueError("run state must be a JSON object")
+            for key in ("last_ok", "healed_at", "fetch_method", "page_hash"):
+                if key in state:
+                    spec[key] = state[key]
+        validate_candidate(spec, spec.get("example"))
+        if spec.get("name") != name or not isinstance(spec.get("url_template"), str):
+            raise ValueError("invalid stored name or url_template")
+        if not isinstance(spec.get("params"), dict) or not all(
+                isinstance(key, str) and isinstance(value, str) for key, value in spec["params"].items()):
+            raise ValueError("stored params must be an object of strings")
+        if not isinstance(spec.get("want"), str):
+            raise ValueError("stored want must be a string")
+        if spec.get("fetch_method", "urllib") not in ("urllib", "crwl"):
+            raise ValueError("stored fetch_method must be urllib or crwl")
+        return spec
+    except (OSError, ValueError, TypeError, KeyError) as exc:
+        raise ReaderError(2, f"cannot load spec {name}: {exc}") from exc
+
+
+def parse_params(values):
+    params = {}
+    for value in values:
+        key, sep, text = value.partition("=")
+        if not sep or not re.fullmatch(r"[A-Za-z_][A-Za-z0-9_]*", key):
+            raise ReaderError(2, "--param must be key=value")
+        params[key] = text
+    return params
+
+
+def render_url(template, params):
+    try:
+        # Only named placeholders are supported, with URL-encoded values.
+        def replace(match):
+            return quote(params[match.group(1)], safe="")
+        url = re.sub(r"\{([A-Za-z_][A-Za-z0-9_]*)\}", replace, template)
+        if "{" in url or "}" in url:
+            raise ValueError("invalid URL template")
+        return url
+    except (KeyError, ValueError) as exc:
+        raise ReaderError(2, f"URL template parameter: {exc}") from exc
+
+
+def run_spec(spec, params, no_heal):
+    url = render_url(spec["url_template"], {**spec["params"], **params})
+    html, fetch_method = fetch(url, preferred=spec.get("fetch_method", "urllib"))
+    try:
+        rows = extract(spec, html)
+        errors = failures(spec, rows)
+    except (ReaderError, ValueError, TypeError, KeyError, re.error) as exc:
+        errors = [str(exc), *spec["required"]]
+    if errors:
+        if no_heal:
+            raise ReaderError(12, "extraction failed; missing fields: " + "; ".join(errors))
+        try:
+            healed, rows = compile_spec(spec["name"], spec["url_template"],
+                                        {**spec["params"], **params}, spec["want"],
+                                        spec.get("example"), html, healed_at=now(),
+                                        required_contract=spec["required"], fetch_method=fetch_method,
+                                        anchor_example=False)
+            # Rerun the replacement spec before replacing the saved file.
+            rows = extract(healed, html)
+            errors = failures(healed, rows)
+            if not errors:
+                save(healed, runtime=True)
+                save_state(healed, html, fetch_method)
+                return {"rows": rows, "meta": {"fetch_method": fetch_method}}
+        except ReaderError as exc:
+            if exc.code == 2:
+                raise
+            errors += [str(exc)]
+        raise ReaderError(12, "extraction failed after one heal; missing fields: " + "; ".join(errors))
+    save_state(spec, html, fetch_method)
+    return {"rows": rows, "meta": {"fetch_method": fetch_method}}
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(description=__doc__)
+    commands = parser.add_subparsers(dest="command", required=True)
+    compile_parser = commands.add_parser("compile", help="compile a public page once")
+    compile_parser.add_argument("name")
+    compile_parser.add_argument("--url", required=True)
+    compile_parser.add_argument("--want", required=True)
+    compile_parser.add_argument("--example")
+    compile_parser.add_argument("--param", action="append", default=[])
+    run_parser = commands.add_parser("run", help="extract without AI, healing once on failure")
+    run_parser.add_argument("name")
+    run_parser.add_argument("--param", action="append", default=[])
+    run_parser.add_argument("--no-heal", action="store_true")
+    commands.add_parser("ls", help="list saved specs")
+    args = parser.parse_args(argv)
+    try:
+        if args.command == "ls":
+            directories = (spec_path("unused").parent, override_path("unused").parent)
+            names = {path.stem for directory in directories for path in directory.glob("*.json")}
+            print("name\turl\ttype\tcompiled_at\tlast_ok\thealed_at\tsource")
+            for name in sorted(names):
+                spec = load(name)
+                print("\t".join(str(spec.get(key) or "") for key in
+                                ("name", "url_template", "type", "compiled_at", "last_ok", "healed_at"))
+                      + "\t" + str(selected_path(name)))
+            return 0
+        spec_path(args.name)
+        params = parse_params(args.param)
+        if args.command == "compile":
+            required_compile_command()
+            try:
+                example = json.loads(args.example) if args.example is not None else None
+                if example is not None and not (isinstance(example, dict) or
+                        isinstance(example, list) and example and all(isinstance(row, dict) for row in example)):
+                    raise ValueError("example must be an object or non-empty list of objects")
+            except ValueError as exc:
+                raise ReaderError(2, f"invalid --example JSON: {exc}") from exc
+            html, fetch_method = fetch(render_url(args.url, params))
+            if example is None:
+                print("reader: warning: wrong-but-plausible values cannot be detected without an example row; "
+                      "use --example to anchor the compile", file=sys.stderr)
+            spec, rows = compile_spec(args.name, args.url, params, args.want, example, html,
+                                      fetch_method=fetch_method)
+            save(spec)
+            output = rows
+        else:
+            output = run_spec(load(args.name), params, args.no_heal)
+        print(json.dumps(output, indent=2, ensure_ascii=False, allow_nan=False))
+        return 0
+    except ReaderError as exc:
+        print(f"reader: {exc}", file=sys.stderr)
+        return exc.code
+    except (OSError, ValueError, TypeError, KeyError) as exc:
+        print(f"reader: invalid spec or local I/O failure: {exc}", file=sys.stderr)
+        return 2
+
+