Validate simple JSON record types

#!/usr/bin/env python3
'Validate simple JSON record types'
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='Validate simple JSON record types')
    parser.add_argument("--input", required=True)
    parser.add_argument("--output", required=True)
    parser.add_argument("--types-file",required=True,help="JSON object mapping fields to type names")
    args = parser.parse_args()
    schema=load(args.types_file)
    checks={"string":lambda v:type(v)==str,"number":lambda v:type(v) in (int,float),"integer":lambda v:type(v)==int,"boolean":lambda v:type(v)==bool,"array":lambda v:type(v)==list,"object":lambda v:type(v)==dict,"null":lambda v:v is None}
    if not isinstance(schema,dict) or any(type(t)!=str or t not in checks for t in schema.values()): raise ValueError("Map fields to supported type names.")
    issues=[]
    for i,row in enumerate(objects(load(args.input)),1):
        for k,t in schema.items():
            if k not in row or not checks[t](row[k]): issues.append({"record":i,"field":k,"expected":t,"problem":"missing" if k not in row else "wrong type"})
    write_json(args.output,issues)

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