aspera-grader-kit 0.1.0__py3-none-any.whl

aspera_grader_kit/__init__.py

@@ -0,0 +1,11 @@
+"""aspera-grader-kit: a small pattern for grading the files knowledge-work agents produce.
+
+Inspect the file into facts, run checks that each test one thing and explain themselves, then score with a rubric
+whose weights sit in plain JSON next to the task.
+"""
+from .checks import Check, Context, Result, check
+from .grade import grade, render
+from .inspect import inspect
+
+__all__ = ["Check", "Context", "Result", "check", "grade", "render", "inspect"]
+__version__ = "0.1.0"

aspera_grader_kit/__main__.py

@@ -0,0 +1,18 @@
+"""python -m aspera_grader_kit <task_dir> <output_file> [--json]"""
+import argparse, json, sys
+
+from .grade import grade, render
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(prog="aspera_grader_kit", description="Grade one output file against one task folder.")
+    ap.add_argument("task_dir"); ap.add_argument("output")
+    ap.add_argument("--json", action="store_true", help="print the full report as JSON")
+    a = ap.parse_args(argv)
+    rep = grade(a.output, a.task_dir)
+    print(json.dumps(rep, indent=2, default=str) if a.json else render(rep))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

aspera_grader_kit/checks.py

@@ -0,0 +1,106 @@
+"""Checks: small functions that each test one thing about an output and say why.
+
+A check gets a Context (the inspected facts, the task and its answer key) and returns a Result. A check that tests a
+list of things (five key values, three required sections) returns one element per item, so the rubric can count every
+item instead of treating the whole list as one pass or fail.
+
+    from aspera_grader_kit import check, Result
+
+    @check("R1", "requirements", "Every key value appears in the memo")
+    def key_values(ctx):
+        return Result.items([(v["item"], str(v["value"]) in ctx.text, v["value"]) for v in ctx.key["values"]])
+"""
+from dataclasses import dataclass, field
+from typing import Callable, Dict, List, Optional
+
+
+@dataclass
+class Result:
+    status: str                      # pass | fail | na | error
+    evidence: str = ""
+    elements: Optional[List[dict]] = None
+
+    @classmethod
+    def ok(cls, evidence=""): return cls("pass", evidence)
+
+    @classmethod
+    def fail(cls, evidence=""): return cls("fail", evidence)
+
+    @classmethod
+    def na(cls, evidence="does not apply"): return cls("na", evidence)
+
+    @classmethod
+    def when(cls, condition, evidence=""):
+        return cls("pass" if condition else "fail", evidence)
+
+    @classmethod
+    def items(cls, triples):
+        """One element per (item, passed, evidence). Passes only when every item passes."""
+        els = [{"item": str(i), "status": "pass" if ok else "fail", "evidence": str(e)} for i, ok, e in triples]
+        if not els: return cls.na("no items to test")
+        n = sum(e["status"] == "pass" for e in els)
+        return cls("pass" if n == len(els) else "fail", "%d of %d items met" % (n, len(els)), els)
+
+    def units(self):
+        """(passed, total) units for scoring, or None when the check does not count."""
+        if self.status not in ("pass", "fail"): return None
+        if self.elements: return sum(e["status"] == "pass" for e in self.elements), len(self.elements)
+        return (1, 1) if self.status == "pass" else (0, 1)
+
+    def to_dict(self):
+        d = {"status": self.status, "evidence": self.evidence}
+        if self.elements is not None: d["elements"] = self.elements
+        return d
+
+
+@dataclass
+class Check:
+    id: str
+    category: str
+    description: str
+    fn: Callable
+    weight: float = 1.0
+
+
+@dataclass
+class Context:
+    path: str
+    facts: dict
+    task: dict = field(default_factory=dict)
+    key: dict = field(default_factory=dict)
+
+    @property
+    def text(self): return self.facts.get("text", "")
+
+
+_REGISTRY: Dict[str, List[Check]] = {}
+
+
+def check(id, category, description, weight=1.0, registry="default"):
+    """Decorator that registers a check function under a registry name (one per task, usually)."""
+    def wrap(fn):
+        _REGISTRY.setdefault(registry, []).append(Check(id, category, description, fn, weight))
+        return fn
+    return wrap
+
+
+def registered(registry="default"):
+    return list(_REGISTRY.get(registry, []))
+
+
+def clear(registry="default"):
+    _REGISTRY.pop(registry, None)
+
+
+def run(checks, ctx):
+    """Run every check; an exception inside a check becomes status 'error' with the message as evidence."""
+    out = {}
+    for c in checks:
+        try:
+            r = c.fn(ctx)
+            if not isinstance(r, Result):
+                raise TypeError("check %s returned %r, not a Result" % (c.id, type(r).__name__))
+        except Exception as e:  # a broken check must never crash the grade
+            r = Result("error", "%s: %s" % (type(e).__name__, e))
+        out[c.id] = r
+    return out

aspera_grader_kit/grade.py

@@ -0,0 +1,63 @@
+"""Grade one output file against one task folder.
+
+A task folder holds:
+    task.md       the brief the agent was given
+    task.json     {"id", "format", "output"}   (format: docx | pptx | xlsx)
+    key.json      the answer key (values, required items); never shown to the agent
+    rubric.json   categories, points and gates
+    checks.py     the task's checks, registered with @check(..., registry=<task id>)
+"""
+import importlib.util, json, os
+
+from . import checks as C
+from . import rubric as R
+from .inspect import inspect
+
+
+def _load_json(task_dir, name, default=None):
+    p = os.path.join(task_dir, name)
+    if not os.path.exists(p): return default
+    with open(p) as f: return json.load(f)
+
+
+def load_task_checks(task_dir, task_id):
+    C.clear(task_id)
+    spec = importlib.util.spec_from_file_location("task_checks_%s" % task_id.replace("-", "_"), os.path.join(task_dir, "checks.py"))
+    mod = importlib.util.module_from_spec(spec); spec.loader.exec_module(mod)
+    return C.registered(task_id)
+
+
+def grade(output_path, task_dir):
+    task = _load_json(task_dir, "task.json"); key = _load_json(task_dir, "key.json", {})
+    rubric = R.load(os.path.join(task_dir, "rubric.json"))
+    checks = load_task_checks(task_dir, task["id"])
+    report = {"task": task["id"], "output": os.path.basename(output_path) if output_path else None, "checks": {}}
+    gates = []
+    if not output_path or not os.path.exists(output_path):
+        gates.append({"id": "missing", "evidence": "no output file"})
+    else:
+        try:
+            facts = inspect(output_path)
+        except Exception as e:
+            gates.append({"id": "unreadable", "evidence": "%s: %s" % (type(e).__name__, e)})
+        else:
+            results = C.run(checks, C.Context(output_path, facts, task, key))
+            report["checks"] = {c.id: dict(results[c.id].to_dict(), category=c.category, description=c.description) for c in checks}
+            report.update(R.score(results, checks, rubric, gates))
+            return report
+    report.update(R.score({}, checks, rubric, gates))   # nothing to check: every category is empty, so the total is 0
+    report["gates"] = gates
+    return report
+
+
+def render(report):
+    """Plain-text summary of a report for the terminal."""
+    lines = ["%s  %s  ->  %.1f / 100" % (report["task"], report.get("output"), report["total"])]
+    for g in report.get("gates", []): lines.append("  GATE %s: %s" % (g["id"], g["evidence"]))
+    for k, c in report.get("categories", {}).items():
+        if c["possible"]: lines.append("  %-20s %5.1f / %5.1f" % (c["label"], c["earned"], c["possible"]))
+    for cid, r in report.get("checks", {}).items():
+        lines.append("  [%s] %-4s %s  (%s)" % (r["status"].upper()[:4].ljust(4), cid, r["description"], r["evidence"]))
+        for e in r.get("elements") or []:
+            if e["status"] != "pass": lines.append("           - missed: %s (%s)" % (e["item"], e["evidence"]))
+    return "\n".join(lines)

aspera_grader_kit/inspect/__init__.py

@@ -0,0 +1,14 @@
+"""File inspectors: turn an Office file into a plain dict of facts. Checks test facts, never raw XML."""
+import os
+
+from . import docx, pptx, xlsx
+
+INSPECTORS = {".docx": docx.inspect, ".pptx": pptx.inspect, ".xlsx": xlsx.inspect}
+
+
+def inspect(path, **kw):
+    """Facts for one file, picked by extension. Raises ValueError for a format with no inspector."""
+    ext = os.path.splitext(path)[1].lower()
+    if ext not in INSPECTORS:
+        raise ValueError("no inspector for %s files" % ext)
+    return INSPECTORS[ext](path, **kw)

aspera_grader_kit/inspect/docx.py

@@ -0,0 +1,162 @@
+"""Read a .docx into plain facts a check can test: body blocks in order (paragraphs with style,
+numbering and run formatting; tables with header-repeat, shading, cell margins, alignment), tracked changes, comments,
+content controls, protection, fields (PAGE, NUMPAGES, TOC, SEQ), headers/footers, footnotes, images, hyperlinks."""
+import re, zipfile
+from lxml import etree
+
+W = "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+NS = {"w": W, "w14": "http://schemas.microsoft.com/office/word/2010/wordml",
+      "r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+      "a": "http://schemas.openxmlformats.org/drawingml/2006/main", "wp": "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing"}
+REL = "{http://schemas.openxmlformats.org/package/2006/relationships}Relationship"
+q = lambda t: "{%s}%s" % (NS[t.split(":")[0]], t.split(":")[1])
+wv = lambda el, path: (el.find(path, NS).get(q("w:val")) if el is not None and el.find(path, NS) is not None else None)
+
+
+def text_of(el, deleted=False):
+    out = []
+    for t in el.iter(q("w:t"), q("w:delText"), q("w:tab"), q("w:br")):
+        if t.tag == q("w:t"): out.append(t.text or "")
+        elif t.tag == q("w:delText") and deleted: out.append(t.text or "")
+        elif t.tag == q("w:tab"): out.append("\t")
+    return "".join(out)
+
+
+def styles(z):
+    if "word/styles.xml" not in z.namelist(): return {}
+    root = etree.fromstring(z.read("word/styles.xml"))
+    return {s.get(q("w:styleId")): (s.find("w:name", NS).get(q("w:val")) if s.find("w:name", NS) is not None else s.get(q("w:styleId")))
+            for s in root.iter(q("w:style"))}
+
+
+def fields_in(el):
+    """Field codes (simple and complex) in an element, upper-cased first word: PAGE, NUMPAGES, TOC, SEQ, REF ..."""
+    codes = [f.get(q("w:instr")) or "" for f in el.iter(q("w:fldSimple"))]
+    codes += [(t.text or "") for t in el.iter(q("w:instrText"))]
+    return [c.strip() for c in codes if c and c.strip()]
+
+
+def para_facts(p, S):
+    ppr = p.find("w:pPr", NS)
+    sid = wv(ppr, "w:pStyle") if ppr is not None else None
+    num = ppr.find("w:numPr", NS) if ppr is not None else None
+    runs = []
+    for r in p.iter(q("w:r")):
+        rpr = r.find("w:rPr", NS); t = text_of(r)
+        if not t.strip(): continue
+        b = rpr is not None and rpr.find("w:b", NS) is not None and (rpr.find("w:b", NS).get(q("w:val")) not in ("0", "false"))
+        sz = wv(rpr, "w:sz"); col = wv(rpr, "w:color"); font = rpr.find("w:rFonts", NS).get(q("w:ascii")) if rpr is not None and rpr.find("w:rFonts", NS) is not None else None
+        sup = wv(rpr, "w:vertAlign") == "superscript" if rpr is not None else False
+        runs.append({"t": t[:200], "b": b, "sz": int(sz) / 2 if sz and sz.isdigit() else None, "color": col, "font": font, "sup": sup})
+    return {"type": "p", "style": S.get(sid, sid) if sid else "Normal", "text": text_of(p)[:1200],
+            "num": {"numId": wv(num, "w:numId"), "ilvl": wv(num, "w:ilvl")} if num is not None else None,
+            "align": wv(ppr, "w:jc") if ppr is not None else None, "runs": runs[:40],
+            "fields": fields_in(p), "has_drawing": p.find(".//w:drawing", NS) is not None or p.find(".//w:pict", NS) is not None,
+            "in_del": text_of(p, deleted=True) != text_of(p)}
+
+
+def table_facts(t, S):
+    rows = []
+    for tr in t.findall("w:tr", NS):
+        trpr = tr.find("w:trPr", NS)
+        cells = []
+        for tc in tr.findall("w:tc", NS):
+            tcpr = tc.find("w:tcPr", NS)
+            shd = tcpr.find("w:shd", NS) if tcpr is not None else None
+            mar = tcpr.find("w:tcMar", NS) if tcpr is not None else None
+            ps = tc.findall("w:p", NS)
+            bold = any(r.find("w:rPr/w:b", NS) is not None for p in ps for r in p.iter(q("w:r")) if text_of(r).strip())
+            colors = sorted({wv(r.find("w:rPr", NS), "w:color") for p in ps for r in p.iter(q("w:r")) if text_of(r).strip() and r.find("w:rPr", NS) is not None} - {None})
+            cells.append({"text": " ".join(text_of(p) for p in ps).strip()[:200], "fill": shd.get(q("w:fill")) if shd is not None else None,
+                          "align": next((wv(p.find("w:pPr", NS), "w:jc") for p in ps if p.find("w:pPr/w:jc", NS) is not None), None),
+                          "margins": {e.tag.split("}")[1]: e.get(q("w:w")) for e in mar} if mar is not None else None, "bold": bold, "colors": colors})
+        spans = sum(int(wv(tc.find("w:tcPr", NS), "w:gridSpan") or 1) if tc.find("w:tcPr", NS) is not None else 1 for tc in tr.findall("w:tc", NS))
+        sizes = [int(sz.get(q("w:val"))) / 2 for sz in tr.iter(q("w:sz")) if sz.get(q("w:val"), "").isdigit() and sz.getparent().tag == q("w:rPr")]
+        rows.append({"header": trpr is not None and trpr.find("w:tblHeader", NS) is not None, "cells": cells, "span": spans, "min_pt": min(sizes) if sizes else None})
+    tpr = t.find("w:tblPr", NS)
+    tmar = tpr.find("w:tblCellMar", NS) if tpr is not None else None
+    grid = [int(g.get(q("w:w")) or 0) for g in t.findall("w:tblGrid/w:gridCol", NS)]
+    return {"type": "table", "grid_w_twips": sum(grid), "style": S.get(wv(tpr, "w:tblStyle"), wv(tpr, "w:tblStyle")) if tpr is not None else None,
+            "n_rows": len(rows), "n_cols": max((len(r["cells"]) for r in rows), default=0),
+            "table_cell_margins": {e.tag.split("}")[1]: e.get(q("w:w")) for e in tmar} if tmar is not None else None,
+            "rows": rows[:60]}
+
+
+def inspect(path):
+    z = zipfile.ZipFile(path); names = z.namelist(); S = styles(z)
+    doc = etree.fromstring(z.read("word/document.xml")); body = doc.find("w:body", NS)
+    blocks = []
+    for el in body:
+        if el.tag == q("w:p"): blocks.append(para_facts(el, S))
+        elif el.tag == q("w:tbl"): blocks.append(table_facts(el, S))
+        elif el.tag == q("w:sdt"):
+            for p in el.iter(q("w:p")): blocks.append(dict(para_facts(p, S), sdt_block=True))
+    ins = [{"author": e.get(q("w:author")), "text": text_of(e)[:300]} for e in doc.iter(q("w:ins"))]
+    dels = [{"author": e.get(q("w:author")), "text": "".join((t.text or "") for t in e.iter(q("w:delText")))[:300]} for e in doc.iter(q("w:del"))]
+    comments = []
+    if "word/comments.xml" in names:
+        for c in etree.fromstring(z.read("word/comments.xml")).iter(q("w:comment")):
+            comments.append({"id": c.get(q("w:id")), "author": c.get(q("w:author")), "text": text_of(c)[:500]})
+    anchors = {}
+    for p in doc.iter(q("w:p")):
+        for s in p.iter(q("w:commentRangeStart"), q("w:commentReference")):
+            anchors.setdefault(s.get(q("w:id")), text_of(p)[:160])
+    for c in comments: c["anchored_in"] = anchors.get(c["id"])
+    sdts = []
+    for s in doc.iter(q("w:sdt")):
+        pr = s.find("w:sdtPr", NS)
+        if pr is None: continue
+        kind = ("dropdown" if pr.find("w:dropDownList", NS) is not None else "combobox" if pr.find("w:comboBox", NS) is not None
+                else "date" if pr.find("w:date", NS) is not None else "checkbox" if pr.find("w14:checkbox", NS) is not None
+                else "richtext" if pr.find("w:richText", NS) is not None else "picture" if pr.find("w:picture", NS) is not None
+                else "text" if pr.find("w:text", NS) is not None else "docpart" if pr.find("w:docPartObj", NS) is not None else "other")
+        items = [li.get(q("w:displayText")) or li.get(q("w:value")) for li in pr.iter(q("w:listItem"))]
+        df = pr.find("w:date/w:dateFormat", NS)
+        sdts.append({"kind": kind, "tag": wv(pr, "w:tag"), "alias": wv(pr, "w:alias"), "placeholder": pr.find("w:showingPlcHdr", NS) is not None or pr.find("w:placeholder", NS) is not None,
+                     "items": items, "date_format": df.get(q("w:val")) if df is not None else None,
+                     "text": text_of(s.find("w:sdtContent", NS))[:120] if s.find("w:sdtContent", NS) is not None else ""})
+    prot = None
+    if "word/settings.xml" in names:
+        dp = etree.fromstring(z.read("word/settings.xml")).find("w:documentProtection", NS)
+        if dp is not None: prot = {"edit": dp.get(q("w:edit")), "enforcement": dp.get(q("w:enforcement")), "password": any("hash" in k.lower() or "salt" in k.lower() for k in dp.attrib)}
+    hf = {}
+    for n in names:
+        m = re.match(r"word/(header|footer)\d+\.xml$", n)
+        if m:
+            root = etree.fromstring(z.read(n)); hf.setdefault(m.group(1), []).append({"text": text_of(root)[:300], "fields": fields_in(root)})
+    sect = body.find("w:sectPr", NS)
+    pg = {}
+    if sect is not None:
+        ps, pm = sect.find("w:pgSz", NS), sect.find("w:pgMar", NS)
+        if ps is not None: pg = {"w_twips": int(ps.get(q("w:w")) or 0), "h_twips": int(ps.get(q("w:h")) or 0)}
+        if pm is not None: pg.update({k: int(pm.get(q("w:" + k)) or 0) for k in ("left", "right", "top", "bottom")})
+    foot = []
+    if "word/footnotes.xml" in names:
+        for f in etree.fromstring(z.read("word/footnotes.xml")).iter(q("w:footnote")):
+            if f.get(q("w:type")) in (None, "normal"): foot.append(text_of(f)[:200])
+    links = []
+    rels = {}
+    if "word/_rels/document.xml.rels" in names:
+        for r in etree.fromstring(z.read("word/_rels/document.xml.rels")).iter(REL):
+            rels[r.get("Id")] = (r.get("Target"), r.get("TargetMode"))
+    for h in doc.iter(q("w:hyperlink")):
+        rid = h.get(q("r:id")); links.append({"text": text_of(h)[:120], "target": rels.get(rid, (None,))[0] if rid else None, "anchor": h.get(q("w:anchor"))})
+    fields = fields_in(doc)
+    images = sum(1 for _ in doc.iter(q("w:drawing"))) + sum(1 for _ in doc.iter(q("w:pict")))
+    dd = {}
+    if "word/styles.xml" in names:
+        sr = etree.fromstring(z.read("word/styles.xml"))
+        rp = sr.find("w:docDefaults/w:rPrDefault/w:rPr", NS)
+        if rp is not None:
+            dd["sz"] = int(wv(rp, "w:sz")) / 2 if wv(rp, "w:sz") and wv(rp, "w:sz").isdigit() else None
+            f = rp.find("w:rFonts", NS); dd["font"] = f.get(q("w:ascii")) if f is not None else None
+        for st in sr.iter(q("w:style")):
+            if st.get(q("w:styleId")) == "Normal":
+                rp = st.find("w:rPr", NS)
+                if rp is not None and wv(rp, "w:sz"): dd["normal_sz"] = int(wv(rp, "w:sz")) / 2
+                if rp is not None and rp.find("w:rFonts", NS) is not None: dd["normal_font"] = rp.find("w:rFonts", NS).get(q("w:ascii"))
+    num_xml = z.read("word/numbering.xml").decode("utf-8", "ignore") if "word/numbering.xml" in names else ""
+    return {"blocks": blocks, "ins": ins, "del": dels, "comments": comments, "sdts": sdts, "protection": prot, "headers_footers": hf,
+            "page": pg, "footnotes": foot, "hyperlinks": links, "fields": fields, "images": images,
+            "has_numbering_part": bool(num_xml), "defaults": dd, "styles_used": sorted({b["style"] for b in blocks if b["type"] == "p"}),
+            "text": "\n".join(b["text"] if b["type"] == "p" else "\n".join(" | ".join(c["text"] for c in r["cells"]) for r in b["rows"]) for b in blocks)}

aspera_grader_kit/inspect/pptx.py

@@ -0,0 +1,132 @@
+"""Read a .pptx into plain facts a check can test: slide size, slides in presentation order, titles, text, fonts and
+sizes (body vs footer zone), charts (and whether each keeps an embedded workbook), tables, pictures, off-canvas shapes,
+source lines and speaker notes. Reads the XML directly, so it needs no PowerPoint and never renders anything."""
+import hashlib, os, re, zipfile
+from lxml import etree
+
+NS = {"p": "http://schemas.openxmlformats.org/presentationml/2006/main",
+      "a": "http://schemas.openxmlformats.org/drawingml/2006/main",
+      "c": "http://schemas.openxmlformats.org/drawingml/2006/chart",
+      "r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships"}
+REL = "{http://schemas.openxmlformats.org/package/2006/relationships}Relationship"
+EMU_IN = 914400
+NUM = re.compile(r"-?\(?\$?\d[\d,]*\.?\d*\)?%?")
+FOOTER_TEXT = re.compile(r"^\s*(sources?|notes?|footnotes?|confidential|©|\*|\d+\s*(/|of)\s*\d+\s*$)", re.I)
+
+
+def _top_y(el):
+    """y offset of the outermost group holding el (child offsets inside a group are in group space)."""
+    y, cur = None, el
+    while cur is not None:
+        if cur.tag == "{%s}grpSp" % NS["p"]:
+            off = cur.find("./p:grpSpPr/a:xfrm/a:off", NS)
+        elif cur.tag == "{%s}graphicFrame" % NS["p"]:
+            off = cur.find("./p:xfrm/a:off", NS)
+        elif cur.tag == "{%s}sp" % NS["p"]:
+            off = cur.find("./p:spPr/a:xfrm/a:off", NS)
+        else:
+            off = None
+        if off is not None: y = int(off.get("y"))
+        cur = cur.getparent()
+    return y
+
+
+def font_roles(root, slide_h):
+    """Split run sizes into body and footer. Footer = footer/date/slide-number placeholder, a shape in the bottom 15% of
+    the slide, or text that starts like a source line, a note or a page number."""
+    body, foot = [], []
+    for shp in list(root.iter("{%s}sp" % NS["p"])) + list(root.iter("{%s}graphicFrame" % NS["p"])):
+        sizes = [int(r.get("sz")) / 100 for r in shp.iter("{%s}rPr" % NS["a"]) if r.get("sz")]
+        if not sizes: continue
+        ph = shp.find(".//p:nvPr/p:ph", NS)
+        y = _top_y(shp)
+        is_foot = (ph is not None and ph.get("type") in ("ftr", "sldNum", "dt")) or (y is not None and y >= 0.85 * slide_h) \
+            or bool(FOOTER_TEXT.match("".join(shp.itertext()).strip()))
+        (foot if is_foot else body).extend(sizes)
+    return body, foot
+
+
+def slide_parts(z):
+    """Slide parts in presentation order (sldIdLst). File names keep their numbers when slides are reordered, so name
+    order is only a fallback."""
+    s = [n for n in z.namelist() if re.match(r"ppt/slides/slide\d+\.xml$", n)]
+    by_name = sorted(s, key=lambda n: int(re.findall(r"\d+", n)[-1]))
+    try:
+        pres = etree.fromstring(z.read("ppt/presentation.xml"))
+        rl = {r.get("Id"): r.get("Target") for r in etree.fromstring(z.read("ppt/_rels/presentation.xml.rels")).iter(REL)}
+        order = []
+        for sid in pres.iter("{%s}sldId" % NS["p"]):
+            t = rl.get(sid.get("{%s}id" % NS["r"]))
+            if t: order.append(os.path.normpath(os.path.join("ppt", t)).replace("\\", "/"))
+        order = [o for o in order if o in s]
+        return order if len(order) == len(s) else by_name
+    except Exception:
+        return by_name
+
+
+def rels(z, part):
+    d, f = os.path.split(part); rp = d + "/_rels/" + f + ".rels"
+    if rp not in z.namelist(): return {}
+    out = {}
+    for r in etree.fromstring(z.read(rp)).iter(REL):
+        if r.get("TargetMode") == "External": continue
+        out[r.get("Id")] = (os.path.normpath(os.path.join(d, r.get("Target"))).replace("\\", "/"), r.get("Type", "").rsplit("/", 1)[-1])
+    return out
+
+
+def numbers_in(text):
+    """Numbers written in text: 1,250 / (3.5) / -4% / $12.0 -> floats; brackets and minus signs mean negative."""
+    vals = []
+    for m in NUM.findall(text):
+        neg = m.startswith("-") or (m.startswith("(") and m.endswith(")"))
+        s = re.sub(r"[^\d.]", "", m)
+        if not s or s == ".": continue
+        try: v = float(s)
+        except ValueError: continue
+        vals.append(-v if neg else v)
+    return vals
+
+
+def inspect(path):
+    z = zipfile.ZipFile(path)
+    pres = etree.fromstring(z.read("ppt/presentation.xml"))
+    sz = pres.find("p:sldSz", NS); W, H = int(sz.get("cx")), int(sz.get("cy"))
+    slides, all_text, all_nums, hashes = [], [], [], []
+    for i, sp in enumerate(slide_parts(z), 1):
+        xml = z.read(sp); root = etree.fromstring(xml); rl = rels(z, sp)
+        hashes.append(hashlib.sha1(xml).hexdigest())
+        texts = ["".join(t.itertext()) for t in root.iter("{%s}p" % NS["a"])]
+        text = "\n".join(t for t in texts if t.strip())
+        charts = embedded = pics = big_pics = tables = offcanvas = 0
+        chart_nums = []
+        for gf in root.iter("{%s}graphicFrame" % NS["p"]):
+            ch = gf.find(".//c:chart", NS)
+            if ch is not None:
+                charts += 1
+                tgt = rl.get(ch.get("{%s}id" % NS["r"]), (None,))[0]
+                if tgt and tgt in z.namelist():
+                    if any(t in ("package", "oleObject") for _, t in rels(z, tgt).values()): embedded += 1
+                    cx = etree.fromstring(z.read(tgt))
+                    chart_nums += [float(v.text) for v in cx.iter("{%s}v" % NS["c"]) if re.match(r"^-?\d+\.?\d*(E-?\d+)?$", v.text or "")]
+            if gf.find(".//a:tbl", NS) is not None: tables += 1
+        for pic in root.iter("{%s}pic" % NS["p"]):
+            pics += 1
+            ext = pic.find(".//a:xfrm/a:ext", NS)
+            if ext is not None and int(ext.get("cx")) * int(ext.get("cy")) > 0.08 * W * H: big_pics += 1
+        for off in root.iter("{%s}off" % NS["a"]):
+            x, y = int(off.get("x")), int(off.get("y"))
+            if x < -EMU_IN * 0.05 or y < -EMU_IN * 0.05 or x > W or y > H: offcanvas += 1
+        sizes = [int(r.get("sz")) / 100 for r in root.iter("{%s}rPr" % NS["a"]) if r.get("sz")]
+        body_sz, foot_sz = font_roles(root, H)
+        slides.append({"slide": i, "title": texts[0][:120] if texts else "", "text": text[:2000],
+                       "charts": charts, "charts_with_workbook": embedded, "tables": tables,
+                       "pictures": pics, "large_pictures": big_pics, "offcanvas_shapes": offcanvas,
+                       "fonts": sorted({e.get("typeface") for e in root.iter("{%s}latin" % NS["a"]) if e.get("typeface")}),
+                       "min_font_pt": min(sizes) if sizes else None,
+                       "min_body_font_pt": min(body_sz) if body_sz else None,
+                       "min_footer_font_pt": min(foot_sz) if foot_sz else None,
+                       "has_source_line": bool(re.search(r"\bsources?\b|\bsource:", text, re.I)),
+                       "has_notes": any(t == "notesSlide" for _, t in rl.values())})
+        all_text.append(text); all_nums += numbers_in(text) + chart_nums
+    return {"slide_w_in": round(W / EMU_IN, 2), "slide_h_in": round(H / EMU_IN, 2), "slides": slides,
+            "text": "\n".join(all_text), "numbers": all_nums, "slide_hashes": hashes}

aspera_grader_kit/inspect/xlsx.py

@@ -0,0 +1,110 @@
+"""Read an .xlsx into plain facts a check can test: sheets, cells (formula, cached value,
+number format, input styling), errors, hard-coded constants in formulas, charts and their ranges, names, validation,
+comments, freeze panes, merged cells, external links; plus a LibreOffice recalculation to compare cached values."""
+import io, os, re, shutil, subprocess, tempfile, zipfile
+import openpyxl
+from openpyxl.utils import get_column_letter
+
+ERR = re.compile(r"^#(REF!|DIV/0!|VALUE!|NAME\?|N/A|NUM!|NULL!|SPILL!|CALC!)")
+CONST = re.compile(r"(?<![A-Za-z_$:\d.])(-?\d+(?:\.\d+)?)(?![\d.]*[:A-Za-z(])")
+BENIGN = {"0", "1", "2", "3", "4", "5", "6", "7", "12", "100", "1000", "-1", "0.5", "365", "4"}
+
+
+def recalc(path):
+    """LibreOffice opens the workbook, recalculates and saves a copy; returns {sheet: {cell: value}} or None."""
+    tmp = tempfile.mkdtemp(prefix="xr-")
+    try:
+        src = os.path.join(tmp, "in.xlsx"); shutil.copy(path, src); out = os.path.join(tmp, "out")
+        os.makedirs(out)
+        subprocess.run(["soffice", "--headless", "--norestore", "-env:UserInstallation=file://" + os.path.join(tmp, "p"),
+                        "--convert-to", "xlsx:Calc MS Excel 2007 XML", "--outdir", out, src], capture_output=True, timeout=600)
+        f = os.path.join(out, "in.xlsx")
+        if not os.path.exists(f): return None
+        wb = openpyxl.load_workbook(f, data_only=True)
+        return {ws.title: {c.coordinate: c.value for row in ws.iter_rows() for c in row if c.value is not None} for ws in wb.worksheets}
+    except Exception:
+        return None
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+
+def inspect(path, with_recalc=True):
+    wbf = openpyxl.load_workbook(path, data_only=False)
+    wbv = openpyxl.load_workbook(path, data_only=True)
+    z = zipfile.ZipFile(path)
+    sheets = []
+    for ws in wbf.worksheets:
+        wv = wbv[ws.title]
+        cells, n_formula, n_num, errs, consts, inputs_styled = [], 0, 0, [], [], 0
+        for row in ws.iter_rows():
+            for c in row:
+                if c.value is None: continue
+                v = wv[c.coordinate].value
+                isf = isinstance(c.value, str) and c.value.startswith("=")
+                if isf:
+                    n_formula += 1
+                    k = [x for x in CONST.findall(re.sub(r"\"[^\"]*\"", "", c.value[1:])) if x not in BENIGN]
+                    if k: consts.append({"cell": c.coordinate, "formula": c.value[:120], "constants": k[:4]})
+                elif isinstance(c.value, (int, float)) and not isinstance(c.value, bool):
+                    n_num += 1
+                    fill = c.fill.fgColor.rgb if c.fill and c.fill.fill_type == "solid" and c.fill.fgColor is not None else None
+                    fc = c.font.color.rgb if c.font and c.font.color is not None and c.font.color.type == "rgb" else None
+                    if (fill and fill not in ("00000000", "FFFFFFFF")) or (fc and fc not in ("FF000000", None)): inputs_styled += 1
+                if isinstance(v, str) and ERR.match(v): errs.append(c.coordinate)
+                if len(cells) < 400:
+                    cells.append({"c": c.coordinate, "f": c.value[:160] if isf else None, "v": v if not isinstance(v, str) else v[:120],
+                                  "fmt": c.number_format if c.number_format != "General" else None})
+        charts = []
+        for ch in getattr(ws, "_charts", []):
+            refs = []
+            try:
+                for s in ch.series:
+                    if s.val and s.val.numRef: refs.append(s.val.numRef.f)
+            except Exception: pass
+            def _axt(ax):
+                try: return bool(ax is not None and ax.title is not None)
+                except Exception: return False
+            pie = "Pie" in type(ch).__name__ or "Doughnut" in type(ch).__name__
+            charts.append({"type": type(ch).__name__, "title": _title(ch), "refs": refs,
+                           "axis_titles": None if pie else (_axt(getattr(ch, "x_axis", None)) and _axt(getattr(ch, "y_axis", None)))})
+        dv = [{"sqref": str(d.sqref), "type": d.type, "formula": d.formula1} for d in ws.data_validations.dataValidation] if ws.data_validations else []
+        comments = [{"cell": c.coordinate, "text": c.comment.text[:200]} for row in ws.iter_rows() for c in row if c.comment]
+        sheets.append({"name": ws.title, "dims": ws.dimensions, "max_row": ws.max_row, "max_col": ws.max_column, "formulas": n_formula,
+                       "numbers": n_num, "inputs_styled": inputs_styled, "errors": errs[:50], "n_errors": len(errs),
+                       "constants_in_formulas": consts[:40], "n_constants_in_formulas": len(consts), "charts": charts,
+                       "freeze": ws.freeze_panes, "merged": [str(m) for m in ws.merged_cells.ranges][:30], "validation": dv[:20],
+                       "comments": comments[:30], "cells": cells, "col_widths": {k: v.width for k, v in list(ws.column_dimensions.items())[:40] if v.width}})
+    ext = [n for n in z.namelist() if n.startswith("xl/externalLinks/")]
+    names = []
+    try: names = [{"name": n, "ref": str(d.attr_text)[:120]} for n, d in wbf.defined_names.items()]
+    except Exception: pass
+    out = {"sheets": sheets, "sheet_names": [s["name"] for s in sheets], "external_links": len(ext), "defined_names": names}
+    rc = recalc(path) if with_recalc else None
+    # _grid: every non-empty value (recalculated when available), for value checks against an answer key
+    out["_grid"] = {ws.title: {c.coordinate: (rc.get(ws.title, {}).get(c.coordinate) if rc is not None and isinstance(c.value, str) and c.value.startswith("=") else wbv[ws.title][c.coordinate].value)
+                               for row in ws.iter_rows() for c in row if c.value is not None} for ws in wbf.worksheets}
+    if with_recalc:
+        out["recalc_ok"] = rc is not None
+        if rc is not None:
+            diffs, rc_err = [], []
+            for ws in wbf.worksheets:
+                wv = wbv[ws.title]; R = rc.get(ws.title, {})
+                for row in ws.iter_rows():
+                    for c in row:
+                        if not (isinstance(c.value, str) and c.value.startswith("=")): continue
+                        a, b = wv[c.coordinate].value, R.get(c.coordinate)
+                        if isinstance(b, str) and ERR.match(b): rc_err.append("%s!%s" % (ws.title, c.coordinate))
+                        if isinstance(a, (int, float)) and isinstance(b, (int, float)) and abs(a - b) > max(1e-6, abs(b) * 1e-6):
+                            diffs.append({"cell": "%s!%s" % (ws.title, c.coordinate), "cached": a, "recalc": b})
+                        elif a is None and b is not None: diffs.append({"cell": "%s!%s" % (ws.title, c.coordinate), "cached": None, "recalc": b if not isinstance(b, str) else b[:40]})
+            out["recalc_diffs"] = diffs[:40]; out["n_recalc_diffs"] = len(diffs); out["recalc_errors"] = rc_err[:40]
+    return out
+
+
+def _title(ch):
+    try:
+        t = ch.title
+        if t is None: return None
+        return " ".join(r.t for p in t.tx.rich.p for r in (p.r or []))[:100]
+    except Exception:
+        return None

aspera_grader_kit/rubric.py

@@ -0,0 +1,61 @@
+"""Rubric: turn check results into a score out of 100.
+
+A rubric is plain JSON, kept next to the task so the weights are visible and versioned:
+
+    {
+      "version": "example-1",
+      "categories": {
+        "requirements": {"label": "Task requirements", "points": 60, "per_item": true},
+        "craft":        {"label": "Craft",             "points": 40}
+      },
+      "gates": {"missing": "zero", "unreadable": "zero"}
+    }
+
+Rules, deliberately simple so a reader can predict a score by hand:
+- Each category earns points x (share of its units passed).
+- per_item: every element of a check counts as one unit (ten required values weigh ten times, not once).
+  Otherwise each check counts once, scaled by its weight.
+- A category with no applicable checks hands its points to the others, so a task is never scored on what it
+  did not ask for.
+- Gates override the sum: "zero" sets the total to 0; {"cap": N} caps it at N.
+These are example mechanics for the kit; tune them for your own tasks.
+"""
+import json
+
+
+def load(path):
+    with open(path) as f:
+        return json.load(f)
+
+
+def score(results, checks, rubric, gates=()):
+    cats = {k: {"label": v.get("label", k), "points": float(v["points"]), "per_item": bool(v.get("per_item")),
+                "num": 0.0, "den": 0.0, "checks": 0}
+            for k, v in rubric["categories"].items()}
+    for c in checks:
+        r = results.get(c.id)
+        u = r.units() if r is not None else None
+        if u is None or c.category not in cats: continue
+        p, n = u; x = cats[c.category]; x["checks"] += 1
+        if x["per_item"]:
+            x["num"] += p; x["den"] += n
+        else:
+            x["num"] += c.weight * p / n; x["den"] += c.weight
+    live = {k: x for k, x in cats.items() if x["den"] > 0}
+    total_points = sum(x["points"] for x in live.values()) or 1.0
+    out_cats, total = {}, 0.0
+    for k, x in cats.items():
+        possible = x["points"] * 100.0 / total_points if k in live else 0.0
+        share = x["num"] / x["den"] if k in live else None
+        earned = possible * share if share is not None else 0.0
+        total += earned
+        out_cats[k] = {"label": x["label"], "possible": round(possible, 2), "earned": round(earned, 2),
+                       "share": None if share is None else round(share, 3), "checks": x["checks"]}
+    applied = []
+    for g in gates:
+        rule = rubric.get("gates", {}).get(g["id"])
+        if rule == "zero":
+            total = 0.0; applied.append(g)
+        elif isinstance(rule, dict) and "cap" in rule:
+            total = min(total, float(rule["cap"])); applied.append(g)
+    return {"total": round(total, 1), "categories": out_cats, "gates": applied, "rubric_version": rubric.get("version")}

aspera_grader_kit-0.1.0.dist-info/METADATA

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: aspera-grader-kit
+Version: 0.1.0
+Summary: Grade the Word, PowerPoint and Excel files AI agents produce: inspectors, explainable checks and a JSON rubric.
+Author-email: Motif Platforms <dsaran@motifplatforms.com>
+License: MIT
+Project-URL: Homepage, https://github.com/motifplatforms/aspera-grader-kit
+Project-URL: Repository, https://github.com/motifplatforms/aspera-grader-kit
+Project-URL: Issues, https://github.com/motifplatforms/aspera-grader-kit/issues
+Project-URL: Writing, https://www.motifplatforms.com/insights
+Project-URL: Company, https://www.motifplatforms.com
+Keywords: llm-evaluation,ai-agents,graders,rubrics,reward-modeling,docx,pptx,xlsx
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: lxml>=4.9
+Requires-Dist: openpyxl>=3.1
+Provides-Extra: examples
+Requires-Dist: python-docx>=1.1; extra == "examples"
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Requires-Dist: python-docx>=1.1; extra == "test"
+Requires-Dist: python-pptx>=0.6; extra == "test"
+Dynamic: license-file
+
+# aspera-grader-kit
+
+[![tests](https://github.com/motifplatforms/aspera-grader-kit/actions/workflows/tests.yml/badge.svg)](https://github.com/motifplatforms/aspera-grader-kit/actions/workflows/tests.yml) [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE) [![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue.svg)](pyproject.toml)
+
+A small, readable pattern for grading the files that knowledge-work agents produce: Word memos, PowerPoint decks and
+Excel models.
+
+Most agent evals grade the chat transcript. The client never sees the transcript. They open the file. A memo with
+its headings faked in bold, a deck whose chart is a pasted picture, or a model with hard-coded numbers inside its
+formulas all *look* correct. They are still wrong, and a grader that only reads text will reward them.
+
+This kit grades the file itself:
+
+```
+output file ──► inspect ──► facts ──► checks ──► results ──► rubric ──► score + reasons
+               (docx/pptx/xlsx)        (one thing each,       (weights in plain JSON,
+                                        says why)              next to the task)
+```
+
+## Quick start
+
+```bash
+pip install -e ".[test]"
+python examples/board-memo/make_samples.py
+python -m aspera_grader_kit examples/board-memo examples/board-memo/samples/board_memo_weak.docx
+```
+
+```
+board-memo  board_memo_weak.docx  ->  26.4 / 100
+  Task requirements     16.4 /  60.0
+  Craft                 10.0 /  40.0
+  [FAIL] R2   Required sections exist as real headings  (0 of 2 items met)
+           - missed: Summary (no heading called Summary)
+  [FAIL] R4   Metrics table has every metric with its value and change  (2 of 4 items met)
+           - missed: Operating expenses (no row)
+           - missed: EBITDA (no row)
+  [FAIL] C2   No faked headings (bold Normal text standing in for a heading)  (fake headings: ['Summary', 'Risks'])
+  ...
+```
+
+The strong sample scores 100. Every point lost comes with the check that took it and the evidence, so a disagreement
+with the grader is a conversation about one line, not about a number.
+
+## What's inside
+
+| Part | What it does |
+|---|---|
+| `inspect/docx.py` | Body blocks in order (style, numbering, run formatting), tables (header rows, shading, margins), tracked changes, comments, content controls, fields, headers/footers, footnotes, hyperlinks |
+| `inspect/pptx.py` | Slides in presentation order, titles, text and numbers, chart count and whether each keeps its workbook, tables, pictures, off-canvas shapes, body vs footer font floors, source lines, notes |
+| `inspect/xlsx.py` | Formulas vs typed numbers, hard-coded constants inside formulas, error cells, charts and their ranges, validation, names, external links, and a LibreOffice recalculation to catch stale cached values |
+| `checks.py` | `@check` decorator, `Result.items()` for per-item checks, runner that turns a crashing check into an `error` result instead of a crashed grade |
+| `rubric.py` | Scores from a JSON rubric: categories, per-item counting, empty categories hand their points on, gates (`zero`, `cap`) |
+| `examples/board-memo` | A complete task: brief, input CSV, answer key, rubric, nine checks and a strong/weak pair of outputs |
+
+## Design rules
+
+1. **Grade the artifact, not the transcript.** Inspect the file the way the client will open it.
+2. **One check, one variable.** A check that tests three things can't tell you which one failed.
+3. **Every check explains itself.** Evidence is part of the result, not a log line.
+4. **Count requirements item by item.** A task with ten required values should weigh them ten times, not once.
+5. **The answer key never reaches the agent.** Keep `key.json` out of anything the agent can read.
+6. **Gates for the unforgivable.** A missing or unopenable file scores zero, however good the reasoning was.
+7. **Weights live in data.** The rubric is JSON in the task folder, versioned with it, readable by a reviewer.
+
+## Writing your own task
+
+Copy `examples/board-memo`, then edit:
+
+- `task.md`: the brief the agent sees.
+- `key.json`: what a correct answer contains.
+- `rubric.json`: categories, points, gates.
+- `checks.py`: checks registered with `@check("ID", "category", "description", registry="<task id>")`.
+
+## Where this comes from
+
+This is the open, generic core of the harness we use at [Motif Platforms](https://www.motifplatforms.com) to grade AI
+agents on real business deliverables. Our production tasks, answer keys, weights and judge prompts stay private. The
+reasoning behind the pattern is in the series
+[Teaching machines to do real work](https://www.motifplatforms.com/insights):
+
+- [Reward hacking explained: how one bad grader teaches AI a thousand bad lessons](https://www.motifplatforms.com/insights/reward-hacking-explained-one-bad-grader)
+- [How to design training exercises for AI agents](https://www.motifplatforms.com/insights/how-to-design-training-exercises-for-ai-agents)
+- [Ten ways a grader lies in AI post-training](https://www.motifplatforms.com/insights/ten-ways-an-ai-grader-lies)
+- [The correct-looking file: why AI agents fail and what experts offer](https://www.motifplatforms.com/insights/why-ai-agents-fail-at-spreadsheets-decks-documents)
+
+Benchmark results from the full harness: [motifplatforms/mosaic-benchmarks](https://github.com/motifplatforms/mosaic-benchmarks).
+
+Need graders or exercises built for your own agents? [dsaran@motifplatforms.com](mailto:dsaran@motifplatforms.com)
+
+## License
+
+MIT

aspera_grader_kit-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+aspera_grader_kit/__init__.py,sha256=knolxvMvIcozdPq-0YuCgAiLj4iVI5LytwaWfXC17zE,475
+aspera_grader_kit/__main__.py,sha256=Nc9bJWsvG35Yank6DNN3lUZRbjZXOygCN9fwDs3-d3I,627
+aspera_grader_kit/checks.py,sha256=QfYALrh6MheqR1VC7RNP-xi1Auyo_J5cs2RpiRZPKxY,3583
+aspera_grader_kit/grade.py,sha256=C56SF6icHBTS3loS7krno4_2Je8nmbZT8IKKgDLg8os,2964
+aspera_grader_kit/rubric.py,sha256=WHLonOiqBLi9Bx6_3eQgpEltzCgdkLS-AbP8oIvp58c,2729
+aspera_grader_kit/inspect/__init__.py,sha256=QRQMmC9kQEvR3X5ZwXKrptmZVZQZJDzOQZ6kfzdUPYc,532
+aspera_grader_kit/inspect/docx.py,sha256=390iUrzhxzRGOOYYFuoh7mHF42R-CmFb4OdwQChgRGk,11005
+aspera_grader_kit/inspect/pptx.py,sha256=IH4sq22HhnS7jC1LZ2laOusbWhvDbNT3Uuvm9h0xPd4,7065
+aspera_grader_kit/inspect/xlsx.py,sha256=YvzoY_FSdrEFdY5KQ6C_YdfMBb0Eig-X8Lhw5pkhL60,7133
+aspera_grader_kit-0.1.0.dist-info/licenses/LICENSE,sha256=L91093P0vyBVPft5_iYp05RWBuuVBBsUPAxE17RJpvM,1072
+aspera_grader_kit-0.1.0.dist-info/METADATA,sha256=14QSFpTVY4x9wpm6DDkMMlx1jWmWCpLRMfbphXy4BZ4,7197
+aspera_grader_kit-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+aspera_grader_kit-0.1.0.dist-info/top_level.txt,sha256=ikuU6Q6js789emYjXSQCEEk_HgLqfXId69pU_29f8Gw,18
+aspera_grader_kit-0.1.0.dist-info/RECORD,,

aspera_grader_kit-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

aspera_grader_kit-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Motif Platforms
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

aspera_grader_kit-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+aspera_grader_kit