Extract and parse embedded JSON-LD blocks

#!/usr/bin/env python3
'Extract and parse embedded JSON-LD blocks'
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)

from html.parser import HTMLParser
import re
import math
import urllib.parse
from collections import Counter, defaultdict

VOID={"area","base","br","col","embed","hr","img","input","link","meta","param","source","track","wbr"}
class Document(HTMLParser):
    def __init__(self):
        super().__init__(convert_charrefs=True)
        self.nodes=[{"tag":"#document","attrs":{},"line":1,"parent":None,"content":[]}]
        self.stack=[0]
        self.comments=[]
    def handle_starttag(self,tag,attrs):
        if len(self.nodes)>=50000 or len(self.stack)>=256: raise ValueError("HTML node/depth limit exceeded.")
        index=len(self.nodes)
        self.nodes.append({"tag":tag,"attrs":dict(attrs),"line":self.getpos()[0],"parent":self.stack[-1],"content":[]})
        self.nodes[self.stack[-1]]["content"].append(index)
        if tag not in VOID: self.stack.append(index)
    def handle_startendtag(self,tag,attrs):
        self.handle_starttag(tag,attrs)
        if tag not in VOID: self.stack.pop()
    def handle_endtag(self,tag):
        for pos in range(len(self.stack)-1,0,-1):
            if self.nodes[self.stack[pos]]["tag"]==tag:
                del self.stack[pos:]
                break
    def handle_data(self,data):
        self.nodes[self.stack[-1]]["content"].append(data)
    def handle_comment(self,data):
        self.comments.append({"line":self.getpos()[0],"comment":data})
def read_document(path):
    if Path(path).stat().st_size>5*1024*1024: raise ValueError("HTML input exceeds 5 MiB.")
    doc=Document()
    doc.feed(Path(path).read_text(encoding="utf-8-sig"))
    doc.close()
    return doc
def text(doc,index=0,skip=frozenset({"script","style","template"})):
    node=doc.nodes[index]
    if node["tag"] in skip: return ""
    return " ".join(text(doc,p,skip) if isinstance(p,int) else p for p in node["content"])
def clean(value):
    return " ".join(value.split())
def selected(doc,tags):
    return [(i,n) for i,n in enumerate(doc.nodes) if n["tag"] in tags]
def ancestor(doc,index,tag):
    parent=doc.nodes[index]["parent"]
    while parent is not None:
        if doc.nodes[parent]["tag"]==tag: return parent
        parent=doc.nodes[parent]["parent"]
    return None
def visible_text(doc):
    bodies=selected(doc,{"body"})
    return clean(text(doc,bodies[0][0] if bodies else 0, frozenset({"head","script","style","template"})))
def resources(doc):
    result=[]
    for i,n in enumerate(doc.nodes):
        attrs=n["attrs"]
        if n["tag"] in {"img","script","iframe","audio","video","source","track","embed","input"} and attrs.get("src"):
            result.append({"tag":n["tag"],"attribute":"src","url":attrs["src"],"line":n["line"]})
        if n["tag"]=="link" and "stylesheet" in (attrs.get("rel") or "").lower().split() and attrs.get("href"):
            result.append({"tag":"link","attribute":"href","url":attrs["href"],"line":n["line"]})
        if n["tag"]=="video" and attrs.get("poster"):
            result.append({"tag":"video","attribute":"poster","url":attrs["poster"],"line":n["line"]})
    return result

def main():
    parser = argparse.ArgumentParser(description='Extract and parse embedded JSON-LD blocks')
    parser.add_argument("--input",required=True,help="Local UTF-8 HTML file")
    parser.add_argument("--output",required=True,help="New result path")
    args = parser.parse_args()
    doc=read_document(args.input)
    result=[]
    for i,n in selected(doc,{"script"}):
        if (n["attrs"].get("type") or "").casefold().split(";")[0].strip()!="application/ld+json": continue
        raw="".join(p for p in n["content"] if isinstance(p,str))
        record={"line":n["line"]}
        try: record.update(valid_json=True,data=json.loads(raw))
        except ValueError as exc: record.update(valid_json=False,error=str(exc))
        result.append(record)
    write_json(args.output,result)

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