analyticsreceipts 0.0.2__py3-none-any.whl

analyticsreceipts/__init__.py

@@ -0,0 +1,3 @@
+"""analyticsreceipts: a four-axis grader with per-answer receipts for analytics agents over a semantic layer."""
+
+__version__ = "0.0.2"

analyticsreceipts/broken.py

@@ -0,0 +1,25 @@
+"""PLANTED BROKEN COMPILER: a control, never a product path.
+
+It compiles exactly like the real compiler except that it drops convention C1: the dataset source is
+`raw_lines` as loaded, so the duplicated 2010-12-01..09 window is counted twice. The canary and the
+December 2010 fixture must FAIL when the server runs with it. If they pass, the eval cannot see a
+broken semantic layer, and its other results mean nothing.
+
+Used only through `python -m analyticsreceipts.control_server --bug drop_c1` (the fixture harness's control
+run) or by passing compile_fn explicitly. The product server has no switch for it. Receipts produced with it
+carry compiler="planted:drop_c1" and a model hash that is not the governed model's.
+"""
+
+import dataclasses
+
+from .compiler import compile_request
+
+BUG_NAME = "drop_c1"
+
+
+def compile_request_broken(model, req):
+    broken = dataclasses.replace(model, dataset_source="SELECT * FROM raw_lines")
+    return compile_request(broken, req)
+
+
+compile_request_broken.compiler_id = f"planted:{BUG_NAME}"

analyticsreceipts/compare.py

@@ -0,0 +1,67 @@
+"""Side-by-side table of two LIVE-LITE replays graded with the same grader. Descriptive only.
+
+  python -m analyticsreceipts.compare replays/live-lite-v1.jsonl replays/live-lite-v2.jsonl --names v1,v2
+
+Prints a markdown table: per arm, answers, axis passes, cells, tool calls, query calls, and the count of
+answerable MCP runs ending in a well-formed query_metric call plus a final numeric answer. Both replays are
+graded by the grader installed now, so a difference comes from the runs, not from grading.
+"""
+
+import argparse
+import collections
+import json
+
+from .live import read_jsonl
+from .report import CELLS, grade_runs, load_refs
+
+AXES = ("a", "b", "c", "d")
+
+
+def summarize(path):
+    golden, _ = load_refs()
+    runs = [r for r in read_jsonl(path) if r.get("kind", "run") == "run" and not r.get("incomplete")]
+    for r in runs:
+        r["id"] = f"{r['item']}/{r['arm']}"
+    grades = {g["run_id"]: g for g in grade_runs(runs)}
+    out = {}
+    for arm in ("mcp", "raw"):
+        rs = [r for r in runs if r["arm"] == arm]
+        gs = [grades[r["id"]] for r in rs]
+        answerable = [r for r in rs if golden[r["item"]]["expected_behavior"] in ("answer", "answer_with_caveat")]
+        tool = "query_metric" if arm == "mcp" else "run_sql"
+        wf = sum(1 for r in answerable if any(c["name"] == tool and not c["tool_error"] and c["result_type"] == "ok"
+                                              for c in r["tool_calls"]) and grades[r["id"]]["c"] is True)
+        row = {"answers": len(gs), "answerable": len(answerable), "well_formed_call_plus_numeric": wf,
+               "tool_calls": sum(len(r["tool_calls"]) for r in rs),
+               "primary_tool_calls (query_metric or run_sql)": sum(1 for r in rs for c in r["tool_calls"] if c["name"] == tool),
+               "median_seconds": sorted(r["seconds"] for r in rs)[len(rs) // 2] if rs else None}
+        for ax in AXES:
+            app = [g[ax] for g in gs if g[ax] != "N/A"]
+            row[ax] = f"{sum(1 for v in app if v is True)}/{len(app)}"
+        cnt = collections.Counter(g["cell"] for g in gs)
+        for c in CELLS:
+            row[c] = cnt[c]
+        out[arm] = row
+    return out
+
+
+def table(a, b, names):
+    keys = list(next(iter(a.values())).keys())
+    lines = [f"| measure | {names[0]} mcp | {names[1]} mcp | {names[0]} raw | {names[1]} raw |", "|---|---|---|---|---|"]
+    for k in keys:
+        lines.append(f"| {k} | {a['mcp'][k]} | {b['mcp'][k]} | {a['raw'][k]} | {b['raw'][k]} |")
+    return "\n".join(lines)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("a")
+    ap.add_argument("b")
+    ap.add_argument("--names", default="v1,v2")
+    x = ap.parse_args()
+    names = x.names.split(",")
+    print(table(summarize(x.a), summarize(x.b), names))
+
+
+if __name__ == "__main__":
+    main()

analyticsreceipts/compiler.py

@@ -0,0 +1,216 @@
+"""Deterministic compiler: a structured metric request -> one DuckDB SQL statement + bound parameters.
+
+Rules (each one has a test):
+  * only governed metrics and declared dimensions; anything else is refused with a typed result,
+    never guessed (no raw SQL path exists);
+  * one dataset, so no joins and no fan-out;
+  * filter values are bound parameters, never interpolated into the SQL text;
+  * ratio and count-distinct metrics are computed from their components inside every group; there is
+    no rollup path that could sum or average them across groups;
+  * the same request (after canonical ordering) always yields byte-identical SQL and the same hash.
+"""
+
+import datetime as dt
+import hashlib
+import json
+from dataclasses import dataclass
+
+from .model import TIME_GRAINS
+
+OPS = ("eq", "ne", "in", "is_null", "not_null")
+ROW_CAP = 1000
+
+
+class RequestError(Exception):
+    """A request the compiler refuses. `result_type` is what the server returns instead of rows."""
+
+    def __init__(self, result_type, reason, candidates=()):
+        super().__init__(reason)
+        self.result_type = result_type
+        self.reason = reason
+        self.candidates = list(candidates)
+
+
+@dataclass(frozen=True)
+class Compiled:
+    sql: str
+    params: tuple
+    sha256: str
+    request: dict  # canonical form
+    columns: tuple
+
+
+def _date(s, what):
+    try:
+        return dt.date.fromisoformat(str(s)).isoformat()
+    except ValueError:
+        raise RequestError("invalid_request", f"{what} must be YYYY-MM-DD, got {s!r}")
+
+
+def _range(r, what):
+    if not isinstance(r, dict) or "start" not in r or "end" not in r:
+        raise RequestError("needs_clarification", f"{what} needs a start and an end date")
+    a, b = _date(r["start"], f"{what}.start"), _date(r["end"], f"{what}.end")
+    if a > b:
+        raise RequestError("invalid_request", f"{what} starts after it ends")
+    return {"start": a, "end": b}
+
+
+def candidates_for(model, text):
+    t = (text or "").lower().replace("_", " ")
+    out = []
+    for m in model.metrics.values():
+        names = [m.name.replace("_", " ")] + [s.lower() for s in m.synonyms]
+        if any(n in t or t in n for n in names if n):
+            out.append(m.name)
+    return sorted(set(out))
+
+
+def canonical(model, req):
+    """Validate and canonicalise. Raises RequestError for anything the model cannot answer."""
+    if not isinstance(req, dict):
+        raise RequestError("invalid_request", "request must be an object")
+    metric = req.get("metric")
+    if not metric:
+        raise RequestError("needs_clarification", "no metric was named", sorted(model.metrics))
+    if metric not in model.metrics:
+        raise RequestError("no_governed_metric", f"no governed metric named {metric!r}",
+                           candidates_for(model, metric))
+    if not req.get("time_range"):
+        raise RequestError("needs_clarification", "a period (time_range) is required")
+    out = {"metric": metric, "time_range": _range(req["time_range"], "time_range")}
+    comp = req.get("comparison_range")
+    out["comparison_range"] = _range(comp, "comparison_range") if comp else None
+    grain = req.get("grain")
+    if grain is not None and grain not in TIME_GRAINS:
+        raise RequestError("invalid_request", f"grain must be one of {TIME_GRAINS}")
+    out["grain"] = grain
+    dims = list(req.get("dimensions") or [])
+    for d in dims:
+        if d not in model.dimensions or model.dimensions[d].is_time:
+            raise RequestError("invalid_request", f"{d!r} is not a declared dimension; use grain for time")
+    if len(set(dims)) != len(dims):
+        raise RequestError("invalid_request", "duplicate dimension")
+    out["dimensions"] = dims
+    filters = []
+    for f in req.get("filters") or []:
+        if not isinstance(f, dict):
+            raise RequestError("invalid_request", "each filter is {dim, op, value}")
+        d, op, v = f.get("dim"), f.get("op"), f.get("value")
+        if d not in model.dimensions or model.dimensions[d].is_time:
+            raise RequestError("invalid_request", f"filter dimension {d!r} is not declared; use time_range for dates")
+        if op not in OPS:
+            raise RequestError("invalid_request", f"filter op must be one of {OPS}")
+        if op in ("is_null", "not_null"):
+            v = None
+        elif op == "in":
+            if not isinstance(v, list) or not v or not all(isinstance(x, str) for x in v):
+                raise RequestError("invalid_request", "op 'in' needs a non-empty list of strings")
+            v = sorted(v)
+        elif not isinstance(v, str):
+            raise RequestError("invalid_request", f"op {op!r} needs a string value")
+        filters.append({"dim": d, "op": op, "value": v})
+    out["filters"] = sorted(filters, key=lambda x: json.dumps(x, sort_keys=True))
+    rk = req.get("ranking")
+    if rk:
+        if rk.get("by", metric) != metric:
+            raise RequestError("invalid_request", "ranking.by must be the requested metric")
+        direction = rk.get("direction", "desc")
+        if direction not in ("asc", "desc"):
+            raise RequestError("invalid_request", "ranking.direction is asc or desc")
+        limit = rk.get("limit")
+        if not isinstance(limit, int) or not 1 <= limit <= ROW_CAP:
+            raise RequestError("invalid_request", f"ranking.limit is an integer 1..{ROW_CAP}")
+        if not dims:
+            raise RequestError("invalid_request", "ranking needs at least one dimension to rank")
+        out["ranking"] = {"by": metric, "direction": direction, "limit": limit}
+    else:
+        out["ranking"] = None
+    return out
+
+
+def _bucket(model, grain):
+    t = model.fields[model.time_dimension]
+    return f"CAST(date_trunc('{grain}', {t}) AS DATE)"
+
+
+def _select(model, req, start, end, label):
+    params = []
+    t = model.fields[model.time_dimension]
+    cols, group, group_exprs = [], [], []
+    if label is not None:
+        cols.append(f"'{label}' AS period")  # label is one of two fixed literals, never user text
+    if req["grain"]:
+        cols.append(f"{_bucket(model, req['grain'])} AS period_start")
+        group.append("period_start")
+        group_exprs.append(_bucket(model, req["grain"]))
+    for d in req["dimensions"]:
+        cols.append(f"{model.fields[d]} AS {d}")
+        group.append(d)
+        # group by the field EXPRESSION: an alias that shadows a raw column (stock_code) would bind to
+        # the raw column and split one trimmed code into several groups
+        group_exprs.append(model.fields[d])
+    cols.append(f"{model.metric_sql(req['metric'])} AS {req['metric']}")
+    where = [f"{t} BETWEEN CAST(? AS DATE) AND CAST(? AS DATE)"]
+    params += [start, end]
+    for f in req["filters"]:
+        e = model.fields[f["dim"]]
+        if f["op"] == "eq":
+            where.append(f"{e} = ?")
+            params.append(f["value"])
+        elif f["op"] == "ne":
+            # "not X" keeps rows where the value is missing; SQL's <> alone would silently drop them
+            where.append(f"({e} <> ? OR {e} IS NULL)")
+            params.append(f["value"])
+        elif f["op"] == "in":
+            where.append(f"{e} IN ({', '.join('?' for _ in f['value'])})")
+            params += f["value"]
+        elif f["op"] == "is_null":
+            where.append(f"{e} IS NULL")
+        else:
+            where.append(f"{e} IS NOT NULL")
+    sql = f"SELECT {', '.join(cols)} FROM {model.dataset_name} WHERE {' AND '.join(where)}"
+    if group_exprs:
+        sql += f" GROUP BY {', '.join(group_exprs)}"
+    return sql, params, group
+
+
+def compile_request(model, req):
+    req = canonical(model, req)
+    with_cte = f"WITH {model.dataset_name} AS ({' '.join(model.dataset_source.split())}) "
+    tr, cr = req["time_range"], req["comparison_range"]
+    if cr:
+        s1, p1, group = _select(model, req, tr["start"], tr["end"], "current")
+        s2, p2, _ = _select(model, req, cr["start"], cr["end"], "comparison")
+        body = f"{s1} UNION ALL {s2}"
+        params = p1 + p2
+        order = ["period DESC"] + group  # 'current' before 'comparison'
+        cols = ("period",)
+    else:
+        body, params, group = _select(model, req, tr["start"], tr["end"], None)
+        order = list(group)
+        cols = ()
+    cols += (("period_start",) if req["grain"] else ()) + tuple(req["dimensions"]) + (req["metric"],)
+    sql = with_cte + f"SELECT * FROM ({body}) AS q"
+    if req["ranking"] and cr:
+        # rank WITHIN each period: top-N of the current period, then top-N of the comparison period
+        rk = req["ranking"]
+        by = f"{req['metric']} {rk['direction'].upper()} NULLS LAST"
+        tiebreak = ", ".join(group)
+        within = by + (f", {tiebreak}" if tiebreak else "")
+        sql += f" QUALIFY row_number() OVER (PARTITION BY period ORDER BY {within}) <= {int(rk['limit'])}"
+        sql += f" ORDER BY period DESC, {within}"
+    elif req["ranking"]:
+        rk = req["ranking"]
+        tiebreak = ", ".join(order)
+        sql += f" ORDER BY {req['metric']} {rk['direction'].upper()} NULLS LAST" + (f", {tiebreak}" if tiebreak else "")
+        sql += f" LIMIT {int(rk['limit'])}"
+    else:
+        if order:
+            sql += f" ORDER BY {', '.join(order)}"
+        sql += f" LIMIT {ROW_CAP + 1}"
+    payload = sql + "\n" + json.dumps(params)
+    return Compiled(sql, tuple(params), hashlib.sha256(payload.encode()).hexdigest(), req, cols)
+
+
+compile_request.compiler_id = "governed"  # recorded in every receipt

analyticsreceipts/contract.py

@@ -0,0 +1,50 @@
+"""The output contract both arms must follow, and its parser.
+
+The agent's last message is one JSON object:
+  {"behavior": "answer" | "clarify" | "abstain",
+   "resolved_spec": {metric, filters, period{start, end, incomplete}, comparison, grain, dimensions, ranking} | null,
+   "answer": "<one or two sentences stating the number>" | null,
+   "clarification_question": "<question>" | null,
+   "abstain_reason": "<reason>" | null}
+"""
+
+import json
+import re
+
+BEHAVIORS = ("answer", "clarify", "abstain")
+
+CONTRACT_TEXT = (
+    "When you are done, reply with ONLY one JSON object and nothing else:\n"
+    '{"behavior": "answer" | "clarify" | "abstain",\n'
+    ' "resolved_spec": {"metric": str, "filters": [{"dim": str, "op": "eq"|"ne"|"in"|"is_null", "value": ...}],\n'
+    '                   "period": {"start": "YYYY-MM-DD", "end": "YYYY-MM-DD", "incomplete": bool},\n'
+    '                   "comparison": {"period": {"start": "YYYY-MM-DD", "end": "YYYY-MM-DD"}} | null,\n'
+    '                   "grain": "day"|"month"|"quarter"|"year"|null, "dimensions": [str],\n'
+    '                   "ranking": {"by": str, "direction": "asc"|"desc", "limit": int} | null} | null,\n'
+    ' "answer": str | null, "clarification_question": str | null, "abstain_reason": str | null}\n'
+    "Use behavior \"clarify\" when the question is ambiguous and \"abstain\" when the data cannot answer it; "
+    "then resolved_spec is null. Set period.incomplete to true when the period extends past the end of the data."
+)
+
+
+def parse_final(text):
+    """Returns (dict, None) or (None, reason). Accepts a fenced ```json block or the first JSON object."""
+    if not text or not text.strip():
+        return None, "empty final message"
+    m = re.search(r"```(?:json)?\s*(\{.*?\})\s*```", text, re.S)
+    candidates = [m.group(1)] if m else []
+    start = text.find("{")
+    if start >= 0:  # the first JSON object, decoded properly (braces inside strings do not count)
+        try:
+            candidates.append(json.JSONDecoder().raw_decode(text, start)[0])
+        except json.JSONDecodeError:
+            pass
+    for c in candidates:
+        if isinstance(c, str):
+            try:
+                c = json.loads(c)
+            except json.JSONDecodeError:
+                continue
+        if isinstance(c, dict) and c.get("behavior") in BEHAVIORS:
+            return c, None
+    return None, "final message is not a contract JSON object"

analyticsreceipts/control_server.py

@@ -0,0 +1,26 @@
+"""CONTROL entry point: the MCP server with a planted broken compiler. Never a product path.
+
+Used by the fixture harness to prove the eval can see a broken semantic layer (the canary and the
+December 2010 fixture must FAIL). Receipts say compiler="planted:<bug>".
+
+Usage: python -m analyticsreceipts.control_server --bug drop_c1 [--db ...] [--model ...]
+"""
+
+import argparse
+import os
+
+from .broken import BUG_NAME, compile_request_broken
+from .server import build_server
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(prog="analyticsreceipts.control_server")
+    ap.add_argument("--bug", required=True, choices=[BUG_NAME])
+    ap.add_argument("--db", default=os.environ.get("ANALYTICSRECEIPTS_DB"))
+    ap.add_argument("--model", default=os.environ.get("ANALYTICSRECEIPTS_MODEL"))
+    a = ap.parse_args(argv)
+    build_server(db_path=a.db, model_path=a.model, compile_fn=compile_request_broken).run("stdio")
+
+
+if __name__ == "__main__":
+    main()

analyticsreceipts/data/OSSIE-NOTICE.md

@@ -0,0 +1,7 @@
+# Vendored: Apache Ossie core spec
+
+`ossie-schema.json` and `spec.md` are copied unmodified from https://github.com/apache/ossie
+(`core-spec/`), commit `6c9386ee95e31c63d06cec88812c3a4969fa9fd9` (2026-09-26).
+Licensed under the Apache License, Version 2.0: `LICENSE` and `NOTICE` here are copied unmodified from the
+same commit (https://www.apache.org/licenses/LICENSE-2.0).
+They are used only to validate `model/online_retail.ossie.yaml` against the specification.

analyticsreceipts/data/online_retail.ossie.yaml

@@ -0,0 +1,128 @@
+version: 0.2.0.dev0
+name: online_retail
+description: >-
+  UK online retailer, invoice lines 2009-12-01 to 2011-12-09 (UCI Online Retail II, dataset 502, CC BY 4.0).
+  Governed metrics for the analyticsreceipts eval. Expressions are ANSI SQL as executed by DuckDB.
+ai_context:
+  instructions: >-
+    Business conventions. (C1) The two yearly sheets overlap on 2010-12-01 to 2010-12-09; that window is
+    counted once. (C2) A product line has a stock code (spaces trimmed) of five digits optionally followed by
+    up to two letters; postage, fees, manual entries, discounts, bad-debt adjustments, samples, charity,
+    tests, gift vouchers and other short codes are non-product. (C3) Revenue means net product revenue:
+    quantity times price over product lines, including cancellation lines (negative quantities), excluding
+    non-product lines. (C4) An order is an invoice that does not start with C (cancellation) or A (bad-debt
+    adjustment) and has at least one product line. (C5) A customer is a distinct customer ID; lines without
+    one are never a customer, and revenue per customer uses only revenue on lines with a customer ID.
+    (C6) A cancellation is an invoice starting with C; cancelled units are minus the summed quantity on its
+    product lines. (C7) Periods are inclusive calendar dates; the data ends 2011-12-09 12:50, so a period
+    after that date is incomplete and must be said to be. (C8) Identical lines within one sheet are kept.
+datasets:
+  - name: lines
+    source: >-
+      SELECT * FROM raw_lines
+      WHERE NOT (source_sheet = 'Year 2010-2011' AND invoice_ts < TIMESTAMP '2010-12-10 00:00:00')
+    primary_key: [source_sheet, row_in_sheet]
+    description: One row per invoice line, with the duplicated 2010-12-01..09 window counted once (C1).
+    fields:
+      - name: invoice
+        expression: {dialects: [{dialect: ANSI_SQL, expression: invoice}]}
+        datatype: String
+      - name: stock_code
+        expression: {dialects: [{dialect: ANSI_SQL, expression: trim(stock_code)}]}
+        datatype: String
+        dimension: {is_time: false}
+        ai_context: {synonyms: [product code, SKU, item]}
+      - name: quantity
+        expression: {dialects: [{dialect: ANSI_SQL, expression: quantity}]}
+        datatype: Integer
+      - name: price
+        expression: {dialects: [{dialect: ANSI_SQL, expression: price}]}
+        datatype: Decimal
+      - name: line_value
+        expression: {dialects: [{dialect: ANSI_SQL, expression: quantity * price}]}
+        datatype: Decimal
+      - name: customer_id
+        expression: {dialects: [{dialect: ANSI_SQL, expression: customer_id}]}
+        datatype: String
+        dimension: {is_time: false}
+        description: Missing on about 22.5 % of lines; filter with is_null to select those lines.
+      - name: country
+        expression: {dialects: [{dialect: ANSI_SQL, expression: country}]}
+        datatype: String
+        dimension: {is_time: false}
+        ai_context: {synonyms: [market, region]}
+      - name: invoice_date
+        expression: {dialects: [{dialect: ANSI_SQL, expression: CAST(invoice_ts AS DATE)}]}
+        datatype: Date
+        dimension: {is_time: true}
+      - name: is_cancellation
+        expression: {dialects: [{dialect: ANSI_SQL, expression: "invoice LIKE 'C%'"}]}
+        datatype: Boolean
+      - name: is_bad_debt
+        expression: {dialects: [{dialect: ANSI_SQL, expression: "invoice LIKE 'A%'"}]}
+        datatype: Boolean
+      - name: is_product
+        expression: {dialects: [{dialect: ANSI_SQL, expression: "trim(stock_code) SIMILAR TO '[0-9]{5}[A-Za-z]{0,2}'"}]}
+        datatype: Boolean
+      - name: is_order_line
+        expression: {dialects: [{dialect: ANSI_SQL, expression: "invoice NOT LIKE 'C%' AND invoice NOT LIKE 'A%' AND trim(stock_code) SIMILAR TO '[0-9]{5}[A-Za-z]{0,2}'"}]}
+        datatype: Boolean
+metrics:
+  - name: net_product_revenue
+    expression: {dialects: [{dialect: ANSI_SQL, expression: "SUM(CASE WHEN lines.is_product THEN lines.line_value END)"}]}
+    description: Net product revenue in GBP (C2, C3). The default meaning of revenue, sales or turnover.
+    datatype: Decimal
+    ai_context:
+      synonyms: [revenue, sales, turnover, net revenue]
+      instructions: Use for revenue unless the question says otherwise. Excludes postage, fees and adjustments.
+    custom_extensions:
+      - vendor_name: analyticsreceipts
+        data: '{"type":"simple","version":"1.0.0","unit":"GBP","non_additive":false,"conventions":["C1","C2","C3"],"status":"approved"}'
+  - name: units_sold
+    expression: {dialects: [{dialect: ANSI_SQL, expression: "SUM(CASE WHEN lines.is_order_line THEN lines.quantity END)"}]}
+    description: Units sold on product lines of orders (C4).
+    datatype: Integer
+    ai_context: {synonyms: [units, quantity sold, items sold]}
+    custom_extensions:
+      - vendor_name: analyticsreceipts
+        data: '{"type":"simple","version":"1.0.0","unit":"units","non_additive":false,"conventions":["C1","C2","C4"],"status":"approved"}'
+  - name: cancelled_units
+    expression: {dialects: [{dialect: ANSI_SQL, expression: "-SUM(CASE WHEN lines.is_cancellation AND lines.is_product THEN lines.quantity END)"}]}
+    description: Units on product lines of cancellation invoices, reported as a positive number (C6).
+    datatype: Integer
+    ai_context: {synonyms: [returned units, cancelled quantity]}
+    custom_extensions:
+      - vendor_name: analyticsreceipts
+        data: '{"type":"simple","version":"1.0.0","unit":"units","non_additive":false,"conventions":["C1","C2","C6"],"status":"approved"}'
+  - name: orders
+    expression: {dialects: [{dialect: ANSI_SQL, expression: "COUNT(DISTINCT CASE WHEN lines.is_order_line THEN lines.invoice END)"}]}
+    description: Count of orders (C4). Cancellation and bad-debt invoices are not orders.
+    datatype: Integer
+    ai_context: {synonyms: [order count, number of orders, purchases]}
+    custom_extensions:
+      - vendor_name: analyticsreceipts
+        data: '{"type":"count_distinct","version":"1.0.0","unit":"orders","non_additive":true,"conventions":["C1","C2","C4"],"status":"approved"}'
+  - name: active_customers
+    expression: {dialects: [{dialect: ANSI_SQL, expression: "COUNT(DISTINCT CASE WHEN lines.is_order_line AND lines.customer_id IS NOT NULL THEN lines.customer_id END)"}]}
+    description: Distinct customer IDs with at least one order (C4, C5).
+    datatype: Integer
+    ai_context: {synonyms: [customers, buyers, number of customers]}
+    custom_extensions:
+      - vendor_name: analyticsreceipts
+        data: '{"type":"count_distinct","version":"1.0.0","unit":"customers","non_additive":true,"conventions":["C1","C2","C4","C5"],"status":"approved"}'
+  - name: revenue_per_customer
+    expression: {dialects: [{dialect: ANSI_SQL, expression: "SUM(CASE WHEN lines.is_product AND lines.customer_id IS NOT NULL THEN lines.line_value END) / NULLIF(COUNT(DISTINCT CASE WHEN lines.is_order_line AND lines.customer_id IS NOT NULL THEN lines.customer_id END), 0)"}]}
+    description: Net product revenue on lines with a customer ID divided by active customers (C5). A ratio.
+    datatype: Decimal
+    ai_context: {synonyms: [average revenue per customer, revenue per buyer, ARPC]}
+    custom_extensions:
+      - vendor_name: analyticsreceipts
+        data: '{"type":"ratio","version":"1.0.0","unit":"GBP per customer","non_additive":true,"conventions":["C1","C2","C3","C5"],"status":"approved"}'
+  - name: cancellation_rate
+    expression: {dialects: [{dialect: ANSI_SQL, expression: "COUNT(DISTINCT CASE WHEN lines.is_cancellation THEN lines.invoice END) * 1.0 / NULLIF(COUNT(DISTINCT CASE WHEN NOT lines.is_bad_debt THEN lines.invoice END), 0)"}]}
+    description: Cancellation invoices divided by invoices starting with a digit or C (A excluded). A ratio between 0 and 1.
+    datatype: Decimal
+    ai_context: {synonyms: [cancel rate, share of invoices cancelled]}
+    custom_extensions:
+      - vendor_name: analyticsreceipts
+        data: '{"type":"ratio","version":"1.0.0","unit":"ratio","non_additive":true,"conventions":["C1","C6"],"status":"approved"}'