| # usage: runpy.sh dump7.py <port> <outdir> <file>... | |
| # Loads each ODF package read-only over UNO and writes a JSON dump of a fixed property set (Task 7, Review Focus 2). | |
| import sys, os, json, hashlib, uno | |
| from unohelp import connect, desktop, load | |
| port, outdir, files = int(sys.argv[1]), sys.argv[2], sys.argv[3:] | |
| LIM = 400 | |
| def v(x, depth=0): | |
| if isinstance(x, uno.Enum): return x.value | |
| if x is None or isinstance(x, (bool, int, float, str)): return x | |
| if isinstance(x, (tuple, list)): return [v(i, depth + 1) for i in x][:200] | |
| if hasattr(x, "typeName"): | |
| if depth > 3: return "<deep>" | |
| try: return {k: v(getattr(x, k), depth + 1) for k in dir(x) if not k.startswith("_") and k not in ("typeName", "value")} | |
| except Exception: return "<struct>" | |
| return "<obj>" | |
| def g(o, n): | |
| try: return v(o.getPropertyValue(n)) | |
| except Exception: return "n/a" | |
| def gs(o, names): return [g(o, n) for n in names] | |
| def h(s): return hashlib.sha256(s.encode("utf-8", "replace")).hexdigest()[:16] | |
| def tryf(f, d="n/a"): | |
| try: return f() | |
| except Exception as e: return d if d != "ERR" else repr(e)[:80] | |
| def has(doc, s): return tryf(lambda: doc.supportsService(s), False) | |
| SHAPE_PROPS = ["FillStyle", "FillColor", "FillTransparence", "FillGradientName", "FillHatchName", "FillBitmapName", "LineStyle", "LineColor", "LineWidth", "CharHeight", "ParaAdjust"] | |
| def shape(s, depth=0): | |
| d = {"t": tryf(lambda: s.ShapeType), "name": tryf(lambda: s.Name), "pos": v(tryf(lambda: s.Position)), "size": v(tryf(lambda: s.Size)), | |
| "text": tryf(lambda: s.String[:80]), "p": gs(s, SHAPE_PROPS)} | |
| t = d["t"] if isinstance(d["t"], str) else "" | |
| if "Connector" in t: | |
| d["conn"] = {"kind": g(s, "EdgeKind"), "start": g(s, "StartPosition"), "end": g(s, "EndPosition"), "bez": g(s, "PolyPolygonBezier")} | |
| if "OLE2" in t: | |
| d["ole"] = {"cls": g(s, "CLSID"), "internal": g(s, "IsInternal"), "model": embedded(tryf(lambda: s.Model, None))} | |
| if "GraphicObject" in t: d["gr"] = gs(s, ["GraphicURL", "Transparency"])[1:] | |
| if tryf(lambda: s.supportsService("com.sun.star.drawing.GroupShape"), False) and depth < 4: | |
| d["kids"] = [shape(s.getByIndex(i), depth + 1) for i in range(min(s.Count, 100))] | |
| return d | |
| def forms_of(page): | |
| out = [] | |
| try: forms = page.Forms | |
| except Exception: return out | |
| def walk(c): | |
| for i in range(min(c.Count, 300)): | |
| e = c.getByIndex(i) | |
| if tryf(lambda: e.supportsService("com.sun.star.form.FormComponents"), False) or tryf(lambda: e.supportsService("com.sun.star.form.component.Form"), False): | |
| out.append(["FORM", tryf(lambda: e.Name)]); walk(e) | |
| else: | |
| names = tryf(lambda: [p.Name for p in e.getPropertySetInfo().getProperties()], []) | |
| out.append([tryf(lambda: e.Name), tryf(lambda: e.ImplementationName), g(e, "ObjIDinMSO") if "ObjIDinMSO" in names else "-", | |
| tryf(lambda: e.getValueBinding() is not None, "-"), tryf(lambda: (e.getListEntrySource() is not None), "-"), len(names)]) | |
| walk(forms) | |
| return out | |
| def chart_info(m): | |
| if m is None: return None | |
| try: | |
| r = {"title": tryf(lambda: m.Title.String if m.HasMainTitle else ""), "diagram": tryf(lambda: m.Diagram.ServiceName if hasattr(m.Diagram, "ServiceName") else m.getDiagram().getDiagramType()), | |
| "addshapes": tryf(lambda: [m.DrawPage.Count, sorted(m.DrawPage.getByIndex(i).ShapeType.split(".")[-1] for i in range(m.DrawPage.Count))]), "intdata": tryf(lambda: m.hasInternalDataProvider())} | |
| return r | |
| except Exception: return "n/a" | |
| def embedded(m, depth=0): | |
| """Dump an embedded model: drawing and spreadsheet documents fully, charts by title/type/additional shapes.""" | |
| if m is None: return None | |
| if depth > 1: return "<deep>" | |
| try: | |
| if has(m, "com.sun.star.drawing.DrawingDocument") or has(m, "com.sun.star.presentation.PresentationDocument"): return {"draw": draw(m)} | |
| if has(m, "com.sun.star.sheet.SpreadsheetDocument"): return {"calc": calc(m)} | |
| if has(m, "com.sun.star.chart2.ChartDocument") or has(m, "com.sun.star.chart.ChartDocument"): return chart_info(m) | |
| return {"other": tryf(lambda: list(m.SupportedServiceNames)[:3])} | |
| except Exception as e: return "ERR " + repr(e)[:80] | |
| def docprops(doc): | |
| p = doc.DocumentProperties | |
| ud = tryf(lambda: [[n, v(p.UserDefinedProperties.getPropertyValue(n))] for n in sorted(i.Name for i in p.UserDefinedProperties.getPropertySetInfo().getProperties())], []) | |
| return {"title": p.Title, "subject": p.Subject, "author": p.Author, "keywords": list(p.Keywords), "desc": p.Description, "gen": p.Generator[:20] if p.Generator else "", | |
| "print_date": v(p.PrintDate), "printed_by": p.PrintedBy, "creation_date": v(p.CreationDate), "template": p.TemplateName, "edit_cycles": p.EditingCycles, | |
| "autoload": [p.AutoloadURL, p.AutoloadSecs], "defaulttarget": p.DefaultTarget, "userdef": ud} | |
| def basic(doc): | |
| out = {} | |
| for k in ("BasicLibraries", "DialogLibraries"): | |
| out[k] = tryf(lambda: sorted(getattr(doc, k).ElementNames), "n/a") | |
| return out | |
| def writer(doc): | |
| o = {} | |
| txt = doc.Text.String | |
| o["text_hash"] = h(txt); o["chars"] = len(txt) | |
| paras = []; ncell = 0 | |
| e = doc.Text.createEnumeration(); tbl = 0; port_hash = [] | |
| while e.hasMoreElements() and len(paras) < LIM: | |
| p = e.nextElement() | |
| if p.supportsService("com.sun.star.text.Paragraph"): | |
| paras.append([len(p.String), g(p, "ParaStyleName"), g(p, "ParaBackColor"), g(p, "ParaBackTransparent"), g(p, "FillStyle"), g(p, "FillColor"), g(p, "FillTransparence"), | |
| g(p, "CharHeight"), g(p, "ParaAdjust"), g(p, "ParaHyphenationMaxLeadingChars"), g(p, "ParaHyphenationMaxTrailingChars"), g(p, "ParaHyphenationMaxHyphens")]) | |
| try: | |
| pe = p.createEnumeration(); sig = [] | |
| while pe.hasMoreElements(): | |
| t = pe.nextElement(); ty = t.TextPortionType; sig.append(ty) | |
| if ty == "TextField": sig.append(tryf(lambda: t.TextField.ServiceName if hasattr(t.TextField, "ServiceName") else ",".join(t.TextField.SupportedServiceNames))) | |
| u = g(t, "HyperLinkURL") | |
| if u: sig.append("URL:" + str(u)) | |
| port_hash.append(h("|".join(map(str, sig)))) | |
| except Exception: port_hash.append("n/a") | |
| else: tbl += 1 | |
| o["paras"] = paras; o["nparas"] = len(paras); o["port_hash"] = h("".join(port_hash)); o["top_tables"] = tbl | |
| ps = doc.StyleFamilies.getByName("PageStyles") | |
| pk = ["Width", "Height", "BackColor", "BackTransparent", "FillStyle", "FillColor", "FillTransparence", "HeaderIsOn", "HeaderBackColor", "HeaderBackTransparent", "HeaderFillStyle", | |
| "HeaderFillColor", "HeaderFillTransparence", "FooterIsOn", "FooterBackColor", "FooterBackTransparent", "FooterFillStyle", "FooterFillColor", "FooterFillTransparence", | |
| "GridMode", "GridBaseWidth", "GridBaseHeight", "GridLines", "GridSnapToChars", "StandardPageMode", "GridRubyHeight", "GridDisplay", "GridPrint", "IsLandscape", "PageStyleLayout"] | |
| o["pagestyles"] = {n: gs(ps.getByName(n), pk) + [bool(g(ps.getByName(n), "BackGraphicURL")), bool(g(ps.getByName(n), "HeaderBackGraphicURL")), bool(g(ps.getByName(n), "FooterBackGraphicURL"))] for n in ps.ElementNames} | |
| pa = doc.StyleFamilies.getByName("ParagraphStyles") | |
| ak = ["ParaBackColor", "ParaBackTransparent", "FillStyle", "FillColor", "FillTransparence", "CharHeight", "ParaHyphenationMaxLeadingChars", "ParaHyphenationMaxTrailingChars", "ParaKeepTogether", "ParaAdjust"] | |
| o["parastyles"] = {n: gs(pa.getByName(n), ak) for n in pa.ElementNames} | |
| cs = doc.StyleFamilies.getByName("CharacterStyles") | |
| o["charstyles"] = {n: gs(cs.getByName(n), ["CharHeight", "CharWeight", "CharColor"]) for n in cs.ElementNames} | |
| fs = doc.StyleFamilies.getByName("FrameStyles") | |
| o["framestyles"] = {n: gs(fs.getByName(n), ["BackColor", "FillStyle", "FillTransparence", "FillColor", "Width", "Height"]) for n in fs.ElementNames} | |
| tabs = [] | |
| for i in range(min(doc.TextTables.Count, 100)): | |
| t = doc.TextTables.getByIndex(i) | |
| cn = list(t.CellNames) | |
| tabs.append({"name": t.Name, "rows": t.Rows.Count, "cols": t.Columns.Count, "cells": len(cn), "cellhash": h("|".join(cn) + "".join(tryf(lambda: t.getCellByName(c).String, "") for c in cn[:300])), | |
| "split": [tryf(lambda: t.Rows.getByIndex(r).IsSplitAllowed) for r in range(min(t.Rows.Count, 50))], "bg": g(t, "BackColor"), "kt": g(t, "Split")}) | |
| o["tables"] = tabs | |
| fld = [] | |
| en = doc.TextFields.createEnumeration() | |
| while en.hasMoreElements() and len(fld) < LIM: | |
| f = en.nextElement() | |
| sn = tryf(lambda: ",".join(f.SupportedServiceNames)) | |
| r = [sn.replace("com.sun.star.text.", "")[:120]] | |
| if "GetReference" in sn: r += gs(f, ["ReferenceFieldPart", "ReferenceFieldSource", "SourceName", "SequenceNumber"]) | |
| if "URL" in sn: r += gs(f, ["URL", "Representation"]) | |
| fld.append(r) | |
| o["fields"] = fld | |
| o["footnotes"] = [doc.Footnotes.Count, [tryf(lambda: doc.Footnotes.getByIndex(i).String[:30], "") for i in range(min(doc.Footnotes.Count, 30))]] | |
| o["endnotes"] = [doc.Endnotes.Count, [tryf(lambda: doc.Endnotes.getByIndex(i).String[:30], "") for i in range(min(doc.Endnotes.Count, 30))]] | |
| fr = [] | |
| for coll, name in ((doc.TextFrames, "frame"), (doc.GraphicObjects, "graphic"), (doc.EmbeddedObjects, "embedded")): | |
| for n in coll.ElementNames[:100]: | |
| f = coll.getByName(n) | |
| fr.append([name, n, g(f, "AnchorType"), g(f, "AnchorPageNo"), g(f, "Width"), g(f, "Height"), g(f, "BackColor"), g(f, "FillTransparence"), g(f, "Transparency"), g(f, "FillStyle"), g(f, "HoriOrientPosition"), g(f, "VertOrientPosition")]) | |
| if name == "embedded": fr[-1].append(embedded(tryf(lambda: f.Model, None))) | |
| o["frames"] = fr | |
| sec = [] | |
| for n in doc.TextSections.ElementNames[:100]: | |
| s = doc.TextSections.getByName(n); sec.append([n, g(s, "FileLink"), g(s, "LinkRegion"), g(s, "IsProtected"), g(s, "IsVisible")]) | |
| o["sections"] = sec | |
| rl = [] | |
| try: | |
| en = doc.Redlines.createEnumeration() | |
| while en.hasMoreElements() and len(rl) < 100: | |
| r = en.nextElement(); rl.append([g(r, "RedlineType"), g(r, "RedlineAuthor"), g(r, "RedlineDateTime"), g(r, "RedlineComment"), g(r, "RedlineSuccessorData") != "n/a" and bool(g(r, "RedlineSuccessorData"))]) | |
| except Exception: rl = "n/a" | |
| o["redlines"] = rl | |
| o["bookmarks"] = tryf(lambda: sorted(doc.Bookmarks.ElementNames)) | |
| o["refmarks"] = tryf(lambda: sorted(doc.ReferenceMarks.ElementNames)) | |
| o["indexes"] = tryf(lambda: doc.DocumentIndexes.Count) | |
| o["shapes"] = [shape(doc.DrawPage.getByIndex(i)) for i in range(min(doc.DrawPage.Count, 150))] | |
| o["forms"] = forms_of(doc.DrawPage) | |
| o["nstyles"] = {k: len(doc.StyleFamilies.getByName(k).ElementNames) for k in doc.StyleFamilies.ElementNames} | |
| return o | |
| def calc(doc): | |
| o = {"sheets": []} | |
| nfs = doc.NumberFormats; ftype = {} | |
| def ft(k): | |
| if k not in ftype: ftype[k] = tryf(lambda: nfs.getByKey(k).Type) | |
| return ftype[k] | |
| for i in range(doc.Sheets.Count): | |
| sh = doc.Sheets.getByIndex(i) | |
| cur = sh.createCursor(); cur.gotoEndOfUsedArea(False) | |
| rng = sh.getCellRangeByPosition(0, 0, cur.RangeAddress.EndColumn, cur.RangeAddress.EndRow) | |
| if cur.RangeAddress.EndColumn > 300 or cur.RangeAddress.EndRow > 3000: | |
| rng = sh.getCellRangeByPosition(0, 0, min(cur.RangeAddress.EndColumn, 300), min(cur.RangeAddress.EndRow, 3000)) | |
| da = rng.DataArray; fa = rng.FormulaArray | |
| so = {"name": sh.Name, "end": [cur.RangeAddress.EndColumn, cur.RangeAddress.EndRow], "data_hash": h(repr(da)), "formula_hash": h(repr(fa)), | |
| "nformulas": sum(1 for r in fa for c in r if isinstance(c, str) and c.startswith("="))} | |
| cells = [] | |
| nrow = min(len(da), 400) | |
| for r in range(nrow): | |
| for c in range(min(len(da[r]), 60)): | |
| if da[r][c] != "" and da[r][c] is not None: | |
| cell = rng.getCellByPosition(c, r) | |
| cells.append([r, c, ft(cell.NumberFormat), cell.getError(), cell.Type.value]) | |
| so["cells_hash"] = h(repr(cells)); so["ncells"] = len(cells) | |
| so["errors"] = sum(1 for x in cells if x[3]) | |
| so["annotations"] = [sh.Annotations.Count, h("".join(tryf(lambda: sh.Annotations.getByIndex(k).String, "") for k in range(min(sh.Annotations.Count, 100))))] | |
| so["charts"] = {n: chart_info(tryf(lambda: sh.Charts.getByName(n).EmbeddedObject, None)) for n in sh.Charts.ElementNames[:30]} | |
| urls = [] | |
| for r in range(nrow): | |
| for c in range(min(len(da[r]), 40)): | |
| if isinstance(fa[r][c], str) and fa[r][c] and not fa[r][c].startswith("="): | |
| cell = rng.getCellByPosition(c, r) | |
| try: | |
| en = cell.Text.createEnumeration() | |
| while en.hasMoreElements(): | |
| pe = en.nextElement().createEnumeration() | |
| while pe.hasMoreElements(): | |
| pt = pe.nextElement() | |
| if pt.TextPortionType == "TextField": urls.append([r, c, tryf(lambda: pt.TextField.URL), tryf(lambda: pt.TextField.Representation)]) | |
| except Exception: pass | |
| if len(urls) > 100: break | |
| so["urls"] = urls | |
| so["shapes"] = [shape(sh.DrawPage.getByIndex(k)) for k in range(min(sh.DrawPage.Count, 100))] | |
| so["forms"] = forms_of(sh.DrawPage) | |
| so["pagestyle"] = sh.PageStyle | |
| so["flags"] = gs(sh, ["IsVisible", "IsProtected"]) | |
| o["sheets"].append(so) | |
| o["dde"] = tryf(lambda: [[n, doc.DDELinks.getByName(n).Application, doc.DDELinks.getByName(n).Topic, doc.DDELinks.getByName(n).Item] for n in doc.DDELinks.ElementNames]) | |
| o["names"] = tryf(lambda: sorted(doc.NamedRanges.ElementNames)) | |
| ps = doc.StyleFamilies.getByName("PageStyles") | |
| o["pagestyles"] = {n: gs(ps.getByName(n), ["BackColor", "BackTransparent", "FillStyle", "HeaderIsOn", "FooterIsOn", "IsLandscape", "Width", "Height", "ScaleToPagesX"]) for n in ps.ElementNames} | |
| cs = doc.StyleFamilies.getByName("CellStyles") | |
| o["cellstyles"] = {n: gs(cs.getByName(n), ["CellBackColor", "IsCellBackgroundTransparent", "CharHeight", "NumberFormat"]) for n in cs.ElementNames} | |
| return o | |
| def draw(doc): | |
| o = {"pages": []} | |
| pages = doc.DrawPages | |
| for i in range(pages.Count): | |
| pg = pages.getByIndex(i) | |
| po = {"name": tryf(lambda: pg.Name), "shapes": [shape(pg.getByIndex(k)) for k in range(min(pg.Count, 300))], "forms": forms_of(pg), | |
| "layout": g(pg, "Layout"), "bg": tryf(lambda: gs(pg.Background, ["FillStyle", "FillColor", "FillTransparence", "FillGradientName"])), "master": tryf(lambda: pg.MasterPage.Name)} | |
| if has(doc, "com.sun.star.presentation.PresentationDocument"): | |
| po["notes"] = tryf(lambda: [pg.NotesPage.getByIndex(k).String[:40] for k in range(min(pg.NotesPage.Count, 20)) if hasattr(pg.NotesPage.getByIndex(k), "String")], "n/a") | |
| o["pages"].append(po) | |
| masters = doc.MasterPages | |
| o["masters"] = [[tryf(lambda: masters.getByIndex(i).Name), len(shape_list(masters.getByIndex(i)))] for i in range(masters.Count)] | |
| for fam in ("graphics", "Default"): | |
| pass | |
| try: | |
| gf = doc.StyleFamilies.getByName("graphics") | |
| o["graphicstyles"] = {n: gs(gf.getByName(n), ["FillStyle", "FillColor", "FillTransparence", "CharHeight", "LineStyle", "LineColor", "TextWritingMode"]) for n in gf.ElementNames} | |
| except Exception: pass | |
| return o | |
| def shape_list(pg): return [shape(pg.getByIndex(k)) for k in range(min(pg.Count, 300))] | |
| DESK = desktop(connect(port)) | |
| os.makedirs(outdir, exist_ok=True) | |
| for f in files: | |
| dest = os.path.join(outdir, os.path.basename(f) + ".json") | |
| if os.path.exists(dest): continue | |
| open(os.path.join(outdir, ".current"), "w").write(f) | |
| out = {} | |
| try: | |
| doc = load(DESK, f) | |
| out["type"] = ("writer" if has(doc, "com.sun.star.text.TextDocument") else "calc" if has(doc, "com.sun.star.sheet.SpreadsheetDocument") | |
| else "impress" if has(doc, "com.sun.star.presentation.PresentationDocument") else "draw" if has(doc, "com.sun.star.drawing.DrawingDocument") else "other") | |
| out["props"] = tryf(lambda: docprops(doc), "ERR") | |
| out["basic"] = basic(doc) | |
| try: | |
| out["body"] = {"writer": writer, "calc": calc, "impress": draw, "draw": draw}.get(out["type"], lambda d: {})(doc) | |
| except Exception as e: | |
| out["body_error"] = repr(e)[:200] | |
| doc.close(True) | |
| except Exception as e: | |
| out["error"] = repr(e)[:200] | |
| json.dump(out, open(dest, "w"), sort_keys=True, indent=0, default=str) | |
| print("done", len(files)) |