Compare JSON structures by path

#!/usr/bin/env python3
'Compare JSON structures by path'
import argparse
import json
from pathlib import Path

def write_json(path, value):
    data = json.dumps(value, indent=2, ensure_ascii=False, allow_nan=False) + "\n"
    with Path(path).open("x", encoding="utf-8", newline="") as handle:
        handle.write(data)

import random
from collections import Counter
import xml.etree.ElementTree as ET

def read_text(path):
    if Path(path).stat().st_size > 10*1024*1024:
        raise ValueError("Input exceeds 10 MiB.")
    return Path(path).read_text(encoding="utf-8-sig")
def reject(value):
    raise ValueError("Nonstandard JSON constant: "+value)
def load(path):
    return json.loads(read_text(path),parse_constant=reject)
def lines(path):
    return [json.loads(s,parse_constant=reject) for s in read_text(path).splitlines() if s.strip()]
def array(value):
    if not isinstance(value,list):
        raise ValueError("Expected an array root.")
    return value
def objects(value):
    value=array(value)
    if not all(isinstance(r,dict) for r in value):
        raise ValueError("Every array item must be an object.")
    return value
def walk(value,path=()):
    yield path,value
    if isinstance(value,dict):
        for k,v in value.items(): yield from walk(v,path+(k,))
    elif isinstance(value,list):
        for i,v in enumerate(value): yield from walk(v,path+(i,))
def pointer(value,path):
    if not path: return value
    if not path.startswith("/"): raise ValueError("Use a /-prefixed JSON Pointer.")
    for part in path[1:].split("/"):
        key=part.replace("~1","/").replace("~0","~")
        if isinstance(value,list):
            if not key.isdigit() or int(key)>=len(value): raise ValueError("Bad array index.")
            value=value[int(key)]
        elif isinstance(value,dict): value=value[key]
        else: raise ValueError("Pointer crosses a scalar.")
    return value
def xml(path):
    text=read_text(path)
    if "<!DOCTYPE" in text.upper() or "<!ENTITY" in text.upper():
        raise ValueError("DTD/entity declarations are refused.")
    try: return ET.fromstring(text)
    except ET.ParseError as exc: raise ValueError(str(exc)) from exc
def save(path,text):
    with Path(path).open("x",encoding="utf-8",newline="") as handle: handle.write(text)

def main():
    parser = argparse.ArgumentParser(description='Compare JSON structures by path')
    parser.add_argument("--input", required=True)
    parser.add_argument("--output", required=True)
    parser.add_argument("--other",required=True)
    args = parser.parse_args()
    changes=[]
    def compare(a,b,path=()):
        if type(a) is not type(b): changes.append({"path":list(path),"kind":"type","before":a,"after":b})
        elif isinstance(a,dict):
            for k in sorted(a.keys()|b.keys()):
                if k not in a or k not in b: changes.append({"path":list(path+(k,)),"kind":"added" if k in b else "removed","value":b[k] if k in b else a[k]})
                else: compare(a[k],b[k],path+(k,))
        elif isinstance(a,list):
            for i in range(max(len(a),len(b))):
                if i>=len(a) or i>=len(b): changes.append({"path":list(path+(i,)),"kind":"added" if i<len(b) else "removed","value":b[i] if i<len(b) else a[i]})
                else: compare(a[i],b[i],path+(i,))
        elif a!=b: changes.append({"path":list(path),"kind":"changed","before":a,"after":b})
    compare(load(args.input),load(args.other))
    write_json(args.output,changes)

if __name__ == "__main__":
    try:
        main()
    except (OSError, ValueError, KeyError, TypeError, ArithmeticError, IndexError, LookupError) as exc:
        raise SystemExit(str(exc))