Summarize storage by extension

import argparse, ast, collections, difflib, fnmatch, gzip, hashlib, io, json, math, os, random, re, shutil, statistics, string, sys, tarfile, textwrap, time, unicodedata, zipfile
from pathlib import Path
import xml.etree.ElementTree as ET

def write_text(path, content):
    path=Path(path)
    path.parent.mkdir(parents=True,exist_ok=True)
    with path.open('x',encoding='utf-8',newline='') as h: h.write(content)
    print('Created',path)

def fresh_dir(path):
    path=Path(path); path.mkdir(parents=True,exist_ok=False); return path

def files_under(root):
    root=Path(root)
    if not root.is_dir(): raise ValueError('Input must be a directory')
    return sorted((p for p in root.rglob('*') if p.is_file() and not p.is_symlink()),key=lambda p:p.as_posix().casefold())

def digest(path):
    h=hashlib.sha256()
    with Path(path).open('rb') as f:
        for b in iter(lambda:f.read(1048576),b''): h.update(b)
    return h.hexdigest()

def positive(n,name):
    if n<=0: raise ValueError(name+' must be positive')

def destination(root,name):
    name=name.replace('\\','/')
    if name.startswith('/') or any(p=='..' or ':' in p for p in name.split('/')): raise ValueError('Unsafe path: '+name)
    p=(root/name).resolve()
    if p!=root.resolve() and root.resolve() not in p.parents: raise ValueError('Path escapes destination')
    return p

def zip_members(z,limit=500000000):
    seen=set(); total=0; result=[]
    for i in z.infolist():
        if i.is_dir(): continue
        destination(Path.cwd(),i.filename)
        key=i.filename.replace('\\','/').casefold()
        if key in seen: raise ValueError('Duplicate/case-colliding member: '+i.filename)
        seen.add(key)
        if ((i.external_attr>>16)&0o170000)==0o120000: raise ValueError('Symlinks unsupported')
        total+=i.file_size
        if total>limit: raise ValueError('Expanded data exceeds limit')
        result.append(i)
    return result

def copy_member(z,i,root):
    p=destination(root,i.filename); p.parent.mkdir(parents=True,exist_ok=True)
    with z.open(i) as src,p.open('xb') as dst: shutil.copyfileobj(src,dst)

def read_input(a): return a.input.read_text(encoding='utf-8-sig')
NS={'w':'http://schemas.openxmlformats.org/wordprocessingml/2006/main','r':'http://schemas.openxmlformats.org/officeDocument/2006/relationships'}
def docx_root(path,member='word/document.xml'):
    with zipfile.ZipFile(path) as z:
        i=z.getinfo(member)
        if i.file_size>30000000: raise ValueError('Document XML exceeds 30 MB')
        return ET.fromstring(z.read(i))
def pdf_reader(path):
    try: from pypdf import PdfReader
    except ImportError as e: raise ValueError('Install dependency: python -m pip install pypdf') from e
    r=PdfReader(path)
    if r.is_encrypted: raise ValueError('Encrypted PDF unsupported')
    return r
def pdf_writer():
    try: from pypdf import PdfWriter
    except ImportError as e: raise ValueError('Install dependency: python -m pip install pypdf') from e
    return PdfWriter()
def save_pdf(w,p):
    Path(p).parent.mkdir(parents=True,exist_ok=True)
    with Path(p).open('xb') as h: w.write(h)
    print('Created',p)

def main():
    parser=argparse.ArgumentParser(description='Total file counts and bytes for each filename extension.')
    parser.add_argument('--input',type=Path,required=True,help='Source file or folder')
    parser.add_argument('--output',type=Path,required=True,help='New result path; must not exist')
    args=parser.parse_args()
    groups=collections.defaultdict(lambda:[0,0])
    for p in files_under(args.input):
        v=groups[p.suffix.lower() or '(none)'];v[0]+=1;v[1]+=p.stat().st_size
    write_text(args.output,'extension\tfiles\tbytes\n'+'\n'.join(f'{k}\t{v[0]}\t{v[1]}' for k,v in sorted(groups.items())))

if __name__=='__main__':
    try: main()
    except (OSError,ValueError,KeyError,zipfile.BadZipFile,tarfile.TarError,ET.ParseError) as error:
        print('Error:',error,file=sys.stderr); sys.exit(2)