字段叫 a/b，为什么工具找成了 a 里面的 b？

"""Read-only plain JSON Pointer string representation; no URI fragments or JSONPath."""
from copy import deepcopy
import csv
import json
from pathlib import Path
import re


def encode(tokens):
    if any(not isinstance(token, str) for token in tokens):
        raise ValueError("string_tokens_required")
    return "".join("/" + token.replace("~", "~0").replace("/", "~1") for token in tokens)


def decode(pointer):
    if not isinstance(pointer, str):
        raise ValueError("pointer_must_be_string")
    if pointer == "":
        return []
    if not pointer.startswith("/"):
        raise ValueError("plain_pointer_must_start_with_slash")
    tokens = pointer[1:].split("/")
    for token in tokens:
        if re.search(r"~(?:[^01]|$)", token):
            raise ValueError("invalid_escape")
    return [token.replace("~1", "/").replace("~0", "~") for token in tokens]


def resolve(document, pointer):
    tokens, node, trace = decode(pointer), document, []
    for depth, token in enumerate(tokens):
        kind = "object" if isinstance(node, dict) else "array" if isinstance(node, list) else "scalar"
        trace.append({"depth": depth, "token": token, "container": kind})
        if isinstance(node, dict):
            if token not in node:
                raise ValueError("missing_object_member")
            node = node[token]
        elif isinstance(node, list):
            if not re.fullmatch(r"0|[1-9][0-9]*", token):
                raise ValueError("invalid_read_array_index")
            index = int(token)
            if index >= len(node):
                raise ValueError("array_index_out_of_range")
            node = node[index]
        else:
            raise ValueError("cannot_descend_into_scalar")
    return {"tokens": tokens, "value": deepcopy(node), "trace": trace}


def main():
    document = {"a/b": "literal slash key", "a": {"b": "nested key"}, "": "empty key",
                "m~n": "tilde key", "~1": "literal tilde-one", "/": "slash key",
                "items": ["first", {"name": "second"}], "01": "object zero-one", "nil": None,
                "percent%2F": "literal percent text"}
    original = deepcopy(document)
    valid = [("root", "", document), ("empty_key", "/", "empty key"),
             ("literal_slash", "/a~1b", "literal slash key"), ("nested", "/a/b", "nested key"),
             ("tilde", "/m~0n", "tilde key"), ("escape_order", "/~01", "literal tilde-one"),
             ("array", "/items/1/name", "second"), ("object_digits", "/01", "object zero-one"),
             ("present_null", "/nil", None), ("literal_percent", "/percent%2F", "literal percent text")]
    invalid = [("array_leading_zero", "/items/01", "invalid_read_array_index"),
               ("append_not_read", "/items/-", "invalid_read_array_index"),
               ("out_of_range", "/items/2", "array_index_out_of_range"),
               ("bad_escape", "/a~2b", "invalid_escape"), ("trailing_tilde", "/m~", "invalid_escape"),
               ("uri_fragment", "#/a~1b", "plain_pointer_must_start_with_slash"),
               ("missing", "/missing", "missing_object_member"),
               ("scalar", "/nil/x", "cannot_descend_into_scalar")]
    rows = []
    for name, pointer, expected in valid:
        result = resolve(document, pointer)
        assert result["value"] == expected
        assert encode(result["tokens"]) == pointer
        rows.append({"case": name, "pointer": pointer, "status": "resolved", **result})
    for name, pointer, expected_error in invalid:
        try:
            resolve(document, pointer)
        except ValueError as error:
            assert str(error) == expected_error
            rows.append({"case": name, "pointer": pointer, "status": "error", "reason": str(error)})
        else:
            raise AssertionError("invalid pointer accepted")
    assert document == original
    result_copy = resolve(document, "")["value"]
    result_copy["a"]["b"] = "changed by a later consumer"
    assert document == original
    naive_pointer = "/" + "/".join(["a/b"])
    correct_pointer = encode(["a/b"])
    assert resolve(document, naive_pointer)["value"] != resolve(document, correct_pointer)["value"]
    wrong_decoded = "~01".replace("~0", "~").replace("~1", "/")
    assert wrong_decoded == "/" and decode("/~01") == ["~1"]
    wire = json.dumps({"path": correct_pointer})
    assert resolve(document, json.loads(wire)["path"])["value"] == "literal slash key"
    for tokens in [[], [""], ["/", "~", "~1"], ["a.b", "x%2Fy", "01"], ['quote"', "\\"]]:
        assert decode(encode(tokens)) == tokens
    report = {"scope": "parsed JSON fixtures; exact-key, read-only plain pointer strings",
              "document": document, "naive_pointer": naive_pointer, "correct_pointer": correct_pointer,
              "json_wire": wire, "cases": rows, "assertions": "passed"}
    Path("json-pointer-report.json").write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
    with Path("json-pointer-ledger.csv").open("w", encoding="utf-8", newline="") as handle:
        writer = csv.DictWriter(handle, fieldnames=["case", "pointer", "status", "reason"])
        writer.writeheader()
        writer.writerows({key: row.get(key, "") for key in writer.fieldnames} for row in rows)
    print("naive /a/b -> nested key; correct /a~1b -> literal slash key")
    print("escape ~01 -> ~1; array /items/01 and /items/- -> errors")
    print(f"PASS: {len(valid)} resolved, {len(invalid)} rejected; token roundtrips and input isolation")


if __name__ == "__main__":
    main()