Andy Gilliom
843 lines
36 KiB
Python
843 lines
36 KiB
Python
#!/usr/bin/env python3
|
||
"""
|
||
Build MPM advertising-financed ROI cap table workbooks.
|
||
|
||
Three model variants, each written as its own workbook:
|
||
|
||
2A Internal — MPM Financed, ROI & Payback
|
||
MPM 30 / Passent 30 / Reseller 10 / End User 30.
|
||
Carries COGS, sale-price and MSRP milestones against MPM's share,
|
||
with interest accruing on the financed capital.
|
||
|
||
2B Internal — MPM Financed, Revenue Distribution
|
||
Same split, no milestones and no cost basis. A straight projection of
|
||
what each party earns.
|
||
|
||
2C Customer-Financed Acquisition
|
||
MPM 5 / Reseller 2.5 / Passent 22.5 / End User 70.
|
||
No MPM capital at risk, so no COGS or sale-price milestone and no
|
||
interest. Carries the MSRP milestone against the End User's share —
|
||
when the customer's 70% pays back what they bought at list.
|
||
|
||
Usage:
|
||
python3 build_cap_table.py config.json --model all --outdir ./out
|
||
python3 build_cap_table.py config.json --model 2A -o internal_roi.xlsx
|
||
|
||
See references/config_schema.md for the config format.
|
||
"""
|
||
|
||
import argparse
|
||
import copy
|
||
import json
|
||
import os
|
||
import sys
|
||
from datetime import date
|
||
|
||
from openpyxl import Workbook
|
||
from openpyxl.styles import Alignment, Border, Font, PatternFill, Side
|
||
from openpyxl.utils import get_column_letter
|
||
|
||
# --------------------------------------------------------------------------
|
||
# Model presets
|
||
# --------------------------------------------------------------------------
|
||
|
||
MODELS = {
|
||
"2A": {
|
||
"key": "2A",
|
||
"title": "Internal — MPM Financed (ROI & Payback)",
|
||
"audience": "Internal. Contains cost and margin data.",
|
||
"shares": {"MPM": 0.30, "Passent": 0.30, "Reseller": 0.10, "End User": 0.30},
|
||
"milestones": ["cogs", "sale", "msrp"],
|
||
"milestone_party": "MPM",
|
||
"interest": True,
|
||
"recurring_borne_by": "MPM",
|
||
"show_cost_basis": True,
|
||
},
|
||
"2B": {
|
||
"key": "2B",
|
||
"title": "Internal — MPM Financed (Revenue Distribution)",
|
||
"audience": "Internal. Revenue only — no cost, margin or payback data.",
|
||
"shares": {"MPM": 0.30, "Passent": 0.30, "Reseller": 0.10, "End User": 0.30},
|
||
"milestones": [],
|
||
"milestone_party": None,
|
||
"interest": False,
|
||
"recurring_borne_by": "MPM",
|
||
"show_cost_basis": False,
|
||
},
|
||
"2C": {
|
||
"key": "2C",
|
||
"title": "Customer-Financed Acquisition",
|
||
"audience": "Customer-facing. No COGS, margin or sale-price data.",
|
||
"shares": {"MPM": 0.05, "Reseller": 0.025, "Passent": 0.225, "End User": 0.70},
|
||
"milestones": ["msrp"],
|
||
"milestone_party": "End User",
|
||
"interest": False,
|
||
"recurring_borne_by": "End User",
|
||
"show_cost_basis": False,
|
||
},
|
||
}
|
||
|
||
# Which cost basis a party is charged recurring licensing at. MPM pays its
|
||
# vendor cost; the End User pays the invoiced price.
|
||
RECURRING_BASIS = {"MPM": "cogs", "End User": "net", "Customer": "net"}
|
||
|
||
# --------------------------------------------------------------------------
|
||
# Styling
|
||
# --------------------------------------------------------------------------
|
||
|
||
MPM_GOLD = "C8A951"
|
||
DARK = "2F2F2F"
|
||
LIGHT = "F2F2F2"
|
||
|
||
FILL_COGS = PatternFill("solid", fgColor="FFF200") # yellow
|
||
FILL_SALE = PatternFill("solid", fgColor="FFA64D") # orange
|
||
FILL_MSRP = PatternFill("solid", fgColor="7ED957") # green
|
||
MILESTONE_FILL = {"cogs": FILL_COGS, "sale": FILL_SALE, "msrp": FILL_MSRP}
|
||
MILESTONE_LABEL = {"cogs": "COGS", "sale": "Sale Price", "msrp": "MSRP"}
|
||
|
||
HDR_FILL = PatternFill("solid", fgColor=DARK)
|
||
HDR_FONT = Font(bold=True, color="FFFFFF", size=10)
|
||
SUB_FILL = PatternFill("solid", fgColor=MPM_GOLD)
|
||
SUB_FONT = Font(bold=True, color="000000", size=10)
|
||
TITLE_FONT = Font(bold=True, size=14)
|
||
LABEL_FONT = Font(bold=True, size=10)
|
||
NOTE_FONT = Font(italic=True, size=9, color="666666")
|
||
|
||
THIN = Side(style="thin", color="BFBFBF")
|
||
BOX = Border(left=THIN, right=THIN, top=THIN, bottom=THIN)
|
||
|
||
MONEY = '"$"#,##0.00'
|
||
MONEY0 = '"$"#,##0'
|
||
PCT = "0.0%"
|
||
|
||
|
||
# --------------------------------------------------------------------------
|
||
# Model
|
||
# --------------------------------------------------------------------------
|
||
|
||
def month_label(start_ym, offset):
|
||
y, m = (int(x) for x in start_ym.split("-")[:2])
|
||
total = (y * 12 + (m - 1)) + offset
|
||
return f"{total // 12}-{total % 12 + 1:02d}"
|
||
|
||
|
||
def ramp_factor(month, ramp_months, start_pct):
|
||
if ramp_months <= 1 or month >= ramp_months:
|
||
return 1.0
|
||
return start_pct + (1.0 - start_pct) * (month - 1) / (ramp_months - 1)
|
||
|
||
|
||
def line_totals(lines):
|
||
msrp = sum(l["msrp_unit"] * l["qty"] for l in lines)
|
||
net = sum(l["net_subtotal"] for l in lines)
|
||
cogs = sum(l["net_subtotal"] - l["margin"] for l in lines)
|
||
return msrp, net, cogs
|
||
|
||
|
||
def resolve_model(cfg, key):
|
||
"""Preset merged with any per-model overrides in the config."""
|
||
spec = copy.deepcopy(MODELS[key])
|
||
override = (cfg.get("models") or {}).get(key, {})
|
||
spec.update(override)
|
||
total = sum(spec["shares"].values())
|
||
if abs(total - 1.0) > 1e-6:
|
||
raise ValueError(f"Model {key} shares sum to {total:.4f}, not 1.0 — "
|
||
f"every dollar of gross must be allocated.")
|
||
return spec
|
||
|
||
|
||
def build_model(cfg, model_key):
|
||
spec = resolve_model(cfg, model_key)
|
||
horizon = cfg.get("horizon_months", 60)
|
||
ramp_months = cfg.get("ramp_months", 12)
|
||
ramp_start = cfg.get("ramp_start_pct", 0.25)
|
||
monthly_gross = cfg["ad_revenue"]["monthly_gross"]
|
||
start_ym = cfg.get("start_date", "2027-01")
|
||
|
||
lines = cfg["lines"]
|
||
one_time = [l for l in lines if not l.get("recurring")]
|
||
recurring = [l for l in lines if l.get("recurring")]
|
||
ot_msrp, ot_net, ot_cogs = line_totals(one_time)
|
||
rc_msrp, rc_net, rc_cogs = line_totals(recurring)
|
||
targets = {"cogs": ot_cogs, "sale": ot_net, "msrp": ot_msrp}
|
||
|
||
# Who pays the ongoing licensing, and at what basis.
|
||
bearer = spec["recurring_borne_by"]
|
||
basis = RECURRING_BASIS.get(bearer, "cogs")
|
||
monthly_recurring = (rc_cogs if basis == "cogs" else rc_net) / 12.0
|
||
|
||
contributions = {}
|
||
for c in cfg.get("client_contributions", []):
|
||
m = int(c["month"])
|
||
contributions[m] = contributions.get(m, 0.0) + float(c["amount"])
|
||
|
||
surge_by_month = {}
|
||
for s in cfg.get("surges", []):
|
||
if not s.get("enabled"):
|
||
continue
|
||
dur = max(1, int(round(float(s.get("months", 1)))))
|
||
per = float(s["total"]) / dur
|
||
for k in range(dur):
|
||
m = int(s["start_month"]) + k
|
||
if 1 <= m <= horizon:
|
||
surge_by_month[m] = surge_by_month.get(m, 0.0) + per
|
||
|
||
# Financing. Principal is MPM's actual cash outlay — the one-time COGS —
|
||
# not the price it would have sold for. You cannot borrow your own margin.
|
||
fin = cfg.get("finance", {})
|
||
rate = float(fin.get("annual_rate", 0.12))
|
||
basis_key = fin.get("principal_basis", "cogs")
|
||
principal = (float(fin["principal_amount"]) if fin.get("principal_amount")
|
||
else targets.get(basis_key, ot_cogs))
|
||
use_interest = bool(spec["interest"]) and rate > 0
|
||
|
||
parties = list(spec["shares"].keys())
|
||
mparty = spec["milestone_party"]
|
||
|
||
rows = []
|
||
cum = {p: 0.0 for p in parties}
|
||
cum_net = 0.0 # milestone party's cumulative, net of what it bears
|
||
cum_interest = 0.0
|
||
balance = principal if use_interest else 0.0
|
||
neg_amort_months = []
|
||
|
||
for m in range(1, horizon + 1):
|
||
rf = ramp_factor(m, ramp_months, ramp_start)
|
||
gross = monthly_gross * rf + surge_by_month.get(m, 0.0)
|
||
contrib = contributions.get(m, 0.0)
|
||
|
||
row = {"month": m, "date": month_label(start_ym, m - 1),
|
||
"ramp": rf, "gross": gross, "contribution": contrib,
|
||
"parties": {}, "cum_parties": {}}
|
||
for p in parties:
|
||
amt = gross * spec["shares"][p]
|
||
cum[p] += amt
|
||
row["parties"][p] = amt
|
||
row["cum_parties"][p] = cum[p]
|
||
|
||
# Cost borne by the milestone party (or by MPM in the 2B case, where
|
||
# there is no milestone but the drag is still worth showing).
|
||
charge_party = mparty or "MPM"
|
||
charge = monthly_recurring if charge_party == bearer else 0.0
|
||
row["recurring_charge"] = charge
|
||
row["charged_party"] = charge_party
|
||
|
||
net = row["parties"].get(charge_party, 0.0) + contrib - charge
|
||
row["net"] = net
|
||
cum_net += net
|
||
row["cum_net"] = cum_net
|
||
|
||
if use_interest:
|
||
interest = balance * rate / 12.0 if balance > 1e-9 else 0.0
|
||
balance += interest
|
||
payment = max(0.0, min(net, balance))
|
||
balance -= payment
|
||
cum_interest += interest
|
||
if interest > 0 and net < interest:
|
||
neg_amort_months.append(m)
|
||
else:
|
||
interest = 0.0
|
||
row["interest"] = interest
|
||
row["cum_interest"] = cum_interest
|
||
row["balance"] = max(0.0, balance) if use_interest else None
|
||
rows.append(row)
|
||
|
||
# A milestone is cleared when the party has recovered the capital *and*
|
||
# the cost of carrying it to that point.
|
||
crossings = {}
|
||
for key in spec["milestones"]:
|
||
t = targets[key]
|
||
hit = None
|
||
for row in rows:
|
||
if row["cum_net"] >= t + row["cum_interest"]:
|
||
hit = row["month"]
|
||
break
|
||
crossings[key] = hit
|
||
|
||
prop_screens = cfg["ad_revenue"].get("screen_count")
|
||
quote_screens = sum(l["qty"] for l in lines if l.get("is_display"))
|
||
pairing = {"proposal": prop_screens, "quote": quote_screens or None,
|
||
"ok": bool(prop_screens and quote_screens and
|
||
abs(prop_screens - quote_screens) < 0.5)}
|
||
|
||
return {
|
||
"cfg": cfg, "spec": spec, "rows": rows, "parties": parties,
|
||
"targets": targets, "crossings": crossings, "horizon": horizon,
|
||
"one_time": one_time, "recurring": recurring,
|
||
"totals": {"one_time": (ot_msrp, ot_net, ot_cogs),
|
||
"recurring_annual": (rc_msrp, rc_net, rc_cogs),
|
||
"contract_msrp": ot_msrp + rc_msrp,
|
||
"contract_net": ot_net + rc_net,
|
||
"contract_cogs": ot_cogs + rc_cogs},
|
||
"monthly_recurring": monthly_recurring,
|
||
"recurring_bearer": bearer,
|
||
"finance": {"rate": rate, "principal": principal,
|
||
"active": use_interest,
|
||
"total_interest": cum_interest,
|
||
"neg_amort_months": neg_amort_months},
|
||
"pairing": pairing,
|
||
}
|
||
|
||
|
||
# --------------------------------------------------------------------------
|
||
# Sheet helpers
|
||
# --------------------------------------------------------------------------
|
||
|
||
def _hdr(ws, row, col, text, fill=HDR_FILL, font=HDR_FONT):
|
||
c = ws.cell(row=row, column=col, value=text)
|
||
c.fill, c.font, c.border = fill, font, BOX
|
||
c.alignment = Alignment(horizontal="center", vertical="center", wrap_text=True)
|
||
return c
|
||
|
||
|
||
def _band(ws, row, text, width):
|
||
c = ws.cell(row=row, column=1, value=text)
|
||
c.fill, c.font = SUB_FILL, SUB_FONT
|
||
ws.merge_cells(start_row=row, start_column=1, end_row=row, end_column=width)
|
||
return c
|
||
|
||
|
||
def _note(ws, row, text, width=6, height=28):
|
||
c = ws.cell(row=row, column=1, value=text)
|
||
c.font = NOTE_FONT
|
||
ws.merge_cells(start_row=row, start_column=1, end_row=row, end_column=width)
|
||
c.alignment = Alignment(wrap_text=True, vertical="top")
|
||
ws.row_dimensions[row].height = height
|
||
|
||
|
||
# --------------------------------------------------------------------------
|
||
# Summary sheet
|
||
# --------------------------------------------------------------------------
|
||
|
||
def write_summary(wb, model):
|
||
cfg, spec = model["cfg"], model["spec"]
|
||
ws = wb.create_sheet("Summary", 0)
|
||
ws.sheet_view.showGridLines = False
|
||
ws.column_dimensions["A"].width = 40
|
||
for col in "BCDEF":
|
||
ws.column_dimensions[col].width = 18
|
||
|
||
ws["A1"] = f"Model {spec['key']} — {spec['title']}"
|
||
ws["A1"].font = TITLE_FONT
|
||
ws["A2"] = cfg.get("project_name", "")
|
||
ws["A2"].font = Font(italic=True, size=11)
|
||
ws["A3"] = spec["audience"]
|
||
ws["A3"].font = Font(bold=True, size=9, color="B00000")
|
||
|
||
r = 5
|
||
for label, val in [
|
||
("Customer", cfg.get("customer", "")),
|
||
("Sales Order", cfg.get("sale_order", "")),
|
||
("Ad Proposal", cfg.get("ad_proposal_ref", "")),
|
||
("Projection Start", cfg.get("start_date", "")),
|
||
("Horizon (months)", model["horizon"]),
|
||
("Prepared", cfg.get("prepared_on", date.today().isoformat())),
|
||
]:
|
||
ws.cell(row=r, column=1, value=label).font = LABEL_FONT
|
||
ws.cell(row=r, column=2, value=val)
|
||
r += 1
|
||
|
||
pc = model["pairing"]
|
||
ws.cell(row=r, column=1, value="Screens — proposal vs. quote").font = LABEL_FONT
|
||
if pc["proposal"] is None or pc["quote"] is None:
|
||
ws.cell(row=r, column=2, value="not reconciled").font = Font(italic=True, color="999999")
|
||
elif pc["ok"]:
|
||
ws.cell(row=r, column=2, value=f"{pc['proposal']:g} / {pc['quote']:g} — match"
|
||
).font = Font(color="1F7A1F", bold=True)
|
||
else:
|
||
ws.cell(row=r, column=2, value=f"{pc['proposal']:g} / {pc['quote']:g} — MISMATCH, verify scope"
|
||
).font = Font(color="B00000", bold=True)
|
||
r += 1
|
||
_note(ws, r, "This model applies one advertising proposal to one sales order. Its revenue "
|
||
"figures are specific to this deployment and are not transferable to any "
|
||
"other quote.", 6, 26)
|
||
r += 2
|
||
|
||
# --- Distribution ----------------------------------------------------
|
||
_band(ws, r, "Revenue Distribution", 6)
|
||
r += 1
|
||
for i, h in enumerate(["Party", "Share", "Steady-State / mo", "Year 1",
|
||
f"{model['horizon']}-Month Total"], start=1):
|
||
_hdr(ws, r, i, h)
|
||
r += 1
|
||
last = model["rows"][-1]
|
||
yr1 = min(12, model["horizon"]) - 1
|
||
gross_ss = cfg["ad_revenue"]["monthly_gross"]
|
||
for p in model["parties"]:
|
||
share = spec["shares"][p]
|
||
ws.cell(row=r, column=1, value=p).font = LABEL_FONT
|
||
c = ws.cell(row=r, column=2, value=share); c.number_format = PCT
|
||
c = ws.cell(row=r, column=3, value=gross_ss * share); c.number_format = MONEY
|
||
c = ws.cell(row=r, column=4, value=model["rows"][yr1]["cum_parties"][p]); c.number_format = MONEY
|
||
c = ws.cell(row=r, column=5, value=last["cum_parties"][p]); c.number_format = MONEY
|
||
if p == "MPM":
|
||
for col in range(1, 6):
|
||
ws.cell(row=r, column=col).fill = PatternFill("solid", fgColor="FFF9E0")
|
||
r += 1
|
||
ws.cell(row=r, column=1, value="Total gross").font = LABEL_FONT
|
||
c = ws.cell(row=r, column=2, value=1.0); c.number_format = PCT
|
||
c = ws.cell(row=r, column=3, value=gross_ss); c.number_format = MONEY
|
||
c = ws.cell(row=r, column=4, value=sum(model["rows"][yr1]["cum_parties"].values())); c.number_format = MONEY
|
||
c = ws.cell(row=r, column=5, value=sum(last["cum_parties"].values())); c.number_format = MONEY
|
||
for col in range(1, 6):
|
||
ws.cell(row=r, column=col).font = LABEL_FONT
|
||
ws.cell(row=r, column=col).border = Border(top=THIN)
|
||
r += 2
|
||
|
||
# --- Financing -------------------------------------------------------
|
||
fin = model["finance"]
|
||
if fin["active"]:
|
||
_band(ws, r, "Financed Capital and Cost of Money", 6)
|
||
r += 1
|
||
payoff = model["crossings"].get("cogs")
|
||
for label, val, fmt in [
|
||
("Principal financed (one-time COGS)", fin["principal"], MONEY),
|
||
("Annual rate", fin["rate"], PCT),
|
||
("Method", "Declining balance; MPM's share services interest first", None),
|
||
("Total interest accrued", fin["total_interest"], MONEY),
|
||
("Balance retired in month", (f"Month {payoff}" if payoff
|
||
else f">{model['horizon']} months"), None),
|
||
]:
|
||
ws.cell(row=r, column=1, value=label).font = LABEL_FONT
|
||
c = ws.cell(row=r, column=2, value=val)
|
||
if fmt:
|
||
c.number_format = fmt
|
||
r += 1
|
||
if fin["neg_amort_months"]:
|
||
ws.cell(row=r, column=1,
|
||
value=f"Negative amortization in months "
|
||
f"{fin['neg_amort_months'][0]}–{fin['neg_amort_months'][-1]}: "
|
||
f"MPM's share does not cover accruing interest during the ramp, "
|
||
f"so the balance grows before it falls.").font = \
|
||
Font(size=9, color="B00000")
|
||
ws.merge_cells(start_row=r, start_column=1, end_row=r, end_column=6)
|
||
ws.cell(row=r, column=1).alignment = Alignment(wrap_text=True, vertical="top")
|
||
ws.row_dimensions[r].height = 28
|
||
r += 1
|
||
r += 1
|
||
|
||
# --- Milestones ------------------------------------------------------
|
||
if spec["milestones"]:
|
||
mparty = spec["milestone_party"]
|
||
_band(ws, r, f"Payoff Milestones — recovered from {mparty}'s share", 6)
|
||
r += 1
|
||
for i, h in enumerate(["Milestone", "Target", "Reached", "Fill"], start=1):
|
||
_hdr(ws, r, i, h)
|
||
r += 1
|
||
for key in spec["milestones"]:
|
||
hit = model["crossings"][key]
|
||
ws.cell(row=r, column=1, value=MILESTONE_LABEL[key]).font = LABEL_FONT
|
||
c = ws.cell(row=r, column=2, value=model["targets"][key]); c.number_format = MONEY
|
||
c = ws.cell(row=r, column=3,
|
||
value=(f"Month {hit}" if hit else f">{model['horizon']} months"))
|
||
c.alignment = Alignment(horizontal="center")
|
||
if not hit:
|
||
c.font = Font(italic=True, color="B00000")
|
||
ws.cell(row=r, column=4).fill = MILESTONE_FILL[key]
|
||
ws.cell(row=r, column=4).border = BOX
|
||
r += 1
|
||
if fin["active"]:
|
||
_note(ws, r, "Milestones clear when cumulative net recovers the target plus the "
|
||
"interest accrued to that month, so they sit later than they would "
|
||
"on a zero-cost-of-capital basis.", 6, 26)
|
||
r += 1
|
||
r += 1
|
||
|
||
# --- ROI ---------------------------------------------------------
|
||
_band(ws, r, f"Return at Month {model['horizon']} — {mparty}", 6)
|
||
r += 1
|
||
cols = ["Basis", "Target", "Cumulative Net"]
|
||
if fin["active"]:
|
||
cols.append("Net of Interest")
|
||
cols.append("ROI")
|
||
for i, h in enumerate(cols, start=1):
|
||
_hdr(ws, r, i, h)
|
||
r += 1
|
||
cum_final = last["cum_net"]
|
||
net_of_int = cum_final - fin["total_interest"]
|
||
for key in spec["milestones"]:
|
||
t = model["targets"][key]
|
||
ws.cell(row=r, column=1, value=MILESTONE_LABEL[key]).font = LABEL_FONT
|
||
c = ws.cell(row=r, column=2, value=t); c.number_format = MONEY
|
||
c = ws.cell(row=r, column=3, value=cum_final); c.number_format = MONEY
|
||
col = 4
|
||
if fin["active"]:
|
||
c = ws.cell(row=r, column=4, value=net_of_int); c.number_format = MONEY
|
||
col = 5
|
||
c = ws.cell(row=r, column=col, value=(net_of_int - t) / t if t else 0)
|
||
c.number_format = PCT
|
||
c.font = Font(color="1F7A1F" if net_of_int >= t else "B00000", bold=True)
|
||
r += 1
|
||
if spec["key"] == "2C":
|
||
_note(ws, r, "This is the End User's return on the system they purchased at list, "
|
||
"funded by their 70% share of advertising revenue. It is not MPM's "
|
||
"return — MPM's position in this model is its 5% share, shown above.",
|
||
6, 26)
|
||
r += 1
|
||
r += 1
|
||
|
||
if not spec["milestones"]:
|
||
_note(ws, r, "This model is a revenue distribution projection only. It carries no cost "
|
||
"basis, no payback milestone and no margin data by design.", 6, 26)
|
||
r += 2
|
||
return ws
|
||
|
||
|
||
# --------------------------------------------------------------------------
|
||
# Monthly projection sheet
|
||
# --------------------------------------------------------------------------
|
||
|
||
def write_projection(wb, model):
|
||
spec = model["spec"]
|
||
ws = wb.create_sheet("Monthly Projection")
|
||
ws.sheet_view.showGridLines = False
|
||
ws["A1"] = f"{model['horizon']}-Month Projection — Model {spec['key']}"
|
||
ws["A1"].font = TITLE_FONT
|
||
|
||
if spec["milestones"]:
|
||
col = 1
|
||
for key in spec["milestones"]:
|
||
c = ws.cell(row=2, column=col, value=f"{MILESTONE_LABEL[key]} recovered")
|
||
c.fill, c.font, c.border = MILESTONE_FILL[key], Font(bold=True, size=9), BOX
|
||
c.alignment = Alignment(horizontal="center")
|
||
col += 2
|
||
|
||
headers = ["Month", "Date", "Ramp %", "Gross Ad Revenue"]
|
||
headers += [f"{p} ({spec['shares'][p]:.1%})" for p in model["parties"]]
|
||
headers += [f"{p} cum." for p in model["parties"]]
|
||
|
||
mparty = spec["milestone_party"] or "MPM"
|
||
detail_start = len(headers) + 1
|
||
if spec["milestones"] or model["monthly_recurring"]:
|
||
headers.append(f"{mparty} recurring cost")
|
||
headers.append(f"{mparty} net")
|
||
if spec["interest"]:
|
||
headers += ["Interest", "Balance"]
|
||
cum_net_col = None
|
||
if spec["milestones"]:
|
||
headers.append(f"{mparty} cumulative net")
|
||
cum_net_col = len(headers)
|
||
|
||
hdr_row = 4
|
||
for i, h in enumerate(headers, start=1):
|
||
_hdr(ws, hdr_row, i, h)
|
||
# Band the party columns so the split reads at a glance.
|
||
ws.merge_cells(start_row=hdr_row - 1, start_column=5,
|
||
end_row=hdr_row - 1, end_column=4 + 2 * len(model["parties"]))
|
||
c = ws.cell(row=hdr_row - 1, column=5, value="Revenue Distribution (monthly, then cumulative)")
|
||
c.fill, c.font = SUB_FILL, SUB_FONT
|
||
c.alignment = Alignment(horizontal="center")
|
||
if detail_start <= len(headers):
|
||
ws.merge_cells(start_row=hdr_row - 1, start_column=detail_start,
|
||
end_row=hdr_row - 1, end_column=len(headers))
|
||
c = ws.cell(row=hdr_row - 1, column=detail_start,
|
||
value=f"{mparty} Position" + (" and Debt Service" if spec["interest"] else ""))
|
||
c.fill, c.font = SUB_FILL, SUB_FONT
|
||
c.alignment = Alignment(horizontal="center")
|
||
|
||
first = hdr_row + 1
|
||
np_ = len(model["parties"])
|
||
for idx, row in enumerate(model["rows"]):
|
||
r = first + idx
|
||
ws.cell(row=r, column=1, value=row["month"]).alignment = Alignment(horizontal="center")
|
||
ws.cell(row=r, column=2, value=row["date"]).alignment = Alignment(horizontal="center")
|
||
c = ws.cell(row=r, column=3, value=row["ramp"]); c.number_format = PCT
|
||
c = ws.cell(row=r, column=4, value=row["gross"]); c.number_format = MONEY0
|
||
for j, p in enumerate(model["parties"]):
|
||
c = ws.cell(row=r, column=5 + j, value=row["parties"][p]); c.number_format = MONEY0
|
||
c = ws.cell(row=r, column=5 + np_ + j, value=row["cum_parties"][p])
|
||
c.number_format = MONEY0
|
||
col = detail_start
|
||
if spec["milestones"] or model["monthly_recurring"]:
|
||
c = ws.cell(row=r, column=col, value=-row["recurring_charge"]); c.number_format = MONEY0
|
||
c = ws.cell(row=r, column=col + 1, value=row["net"]); c.number_format = MONEY0
|
||
col += 2
|
||
if spec["interest"]:
|
||
c = ws.cell(row=r, column=col, value=-row["interest"]); c.number_format = MONEY0
|
||
c = ws.cell(row=r, column=col + 1, value=row["balance"]); c.number_format = MONEY0
|
||
col += 2
|
||
if cum_net_col:
|
||
c = ws.cell(row=r, column=cum_net_col, value=row["cum_net"])
|
||
c.number_format = MONEY0
|
||
c.font = Font(bold=True)
|
||
if idx % 2 == 1:
|
||
for cc in range(1, len(headers) + 1):
|
||
if not ws.cell(row=r, column=cc).fill.fgColor.rgb or \
|
||
ws.cell(row=r, column=cc).fill.fgColor.rgb == "00000000":
|
||
ws.cell(row=r, column=cc).fill = PatternFill("solid", fgColor=LIGHT)
|
||
|
||
if cum_net_col:
|
||
for key in ["cogs", "sale", "msrp"]:
|
||
if key not in spec["milestones"]:
|
||
continue
|
||
hit = model["crossings"][key]
|
||
if hit:
|
||
cell = ws.cell(row=first + hit - 1, column=cum_net_col)
|
||
cell.fill, cell.border = MILESTONE_FILL[key], BOX
|
||
|
||
for i, w in enumerate([8, 10, 9, 17], start=1):
|
||
ws.column_dimensions[get_column_letter(i)].width = w
|
||
for i in range(5, len(headers) + 1):
|
||
ws.column_dimensions[get_column_letter(i)].width = 15
|
||
ws.freeze_panes = ws.cell(row=first, column=3)
|
||
return ws
|
||
|
||
|
||
# --------------------------------------------------------------------------
|
||
# Cost basis sheet (2A only)
|
||
# --------------------------------------------------------------------------
|
||
|
||
def write_cost_basis(wb, model):
|
||
ws = wb.create_sheet("Cost Basis")
|
||
ws.sheet_view.showGridLines = False
|
||
ws["A1"] = "Odoo Line-Item Cost Basis"
|
||
ws["A1"].font = TITLE_FONT
|
||
ws["A2"] = f"Source: {model['cfg'].get('sale_order','')}"
|
||
ws["A2"].font = Font(italic=True, size=10)
|
||
|
||
headers = ["Line Item", "Qty", "MSRP / Unit", "Extended MSRP", "Disc %",
|
||
"Net Subtotal", "Margin", "COGS", "Type"]
|
||
hdr_row = 4
|
||
for i, h in enumerate(headers, start=1):
|
||
_hdr(ws, hdr_row, i, h)
|
||
|
||
r = hdr_row + 1
|
||
for gname, group in [("One-Time (financed capital)", model["one_time"]),
|
||
("Recurring (annual, ongoing)", model["recurring"])]:
|
||
if not group:
|
||
continue
|
||
_band(ws, r, gname, len(headers))
|
||
r += 1
|
||
for l in group:
|
||
cogs = l["net_subtotal"] - l["margin"]
|
||
ws.cell(row=r, column=1, value=l["name"])
|
||
ws.cell(row=r, column=2, value=l["qty"])
|
||
for col, val, fmt in [(3, l["msrp_unit"], MONEY),
|
||
(4, l["msrp_unit"] * l["qty"], MONEY),
|
||
(5, l.get("discount", 0) / 100.0, PCT),
|
||
(6, l["net_subtotal"], MONEY),
|
||
(7, l["margin"], MONEY), (8, cogs, MONEY)]:
|
||
cc = ws.cell(row=r, column=col, value=val); cc.number_format = fmt
|
||
ws.cell(row=r, column=9,
|
||
value="Recurring/yr" if l.get("recurring") else "One-time")
|
||
if l["margin"] == 0 and l["net_subtotal"] > 0:
|
||
ws.cell(row=r, column=7).font = Font(color="B00000", bold=True)
|
||
elif abs(l["margin"] - l["net_subtotal"]) < 1e-6 and l["net_subtotal"] > 0:
|
||
ws.cell(row=r, column=8).font = Font(color="B00000", bold=True)
|
||
ws.cell(row=r, column=9, value="One-time — no cost set, verify")
|
||
r += 1
|
||
msrp, net, cogs = line_totals(group)
|
||
ws.cell(row=r, column=1, value=f"Subtotal — {gname}").font = LABEL_FONT
|
||
for col, val in [(4, msrp), (6, net), (8, cogs)]:
|
||
cc = ws.cell(row=r, column=col, value=val)
|
||
cc.number_format, cc.font = MONEY, LABEL_FONT
|
||
cc.border = Border(top=THIN, bottom=Side(style="double"))
|
||
r += 2
|
||
|
||
t = model["totals"]
|
||
ws.cell(row=r, column=1, value="TOTAL CONTRACT (yr 1 as quoted)").font = Font(bold=True, size=11)
|
||
for col, val in [(4, t["contract_msrp"]), (6, t["contract_net"]), (8, t["contract_cogs"])]:
|
||
cc = ws.cell(row=r, column=col, value=val)
|
||
cc.number_format, cc.font, cc.fill = MONEY, Font(bold=True, size=11), SUB_FILL
|
||
r += 2
|
||
mr = model["monthly_recurring"]
|
||
_note(ws, r, f"Recurring cost carried monthly against {model['recurring_bearer']}: "
|
||
f"${mr:,.2f}/mo (${mr * 12:,.2f}/yr, ${mr * model['horizon']:,.2f} over "
|
||
f"{model['horizon']} months). Red COGS figures are lines with no standard "
|
||
f"cost in Odoo — the true COGS target is higher than shown.", 9, 30)
|
||
|
||
ws.column_dimensions["A"].width = 62
|
||
for col in "BCDEFGH":
|
||
ws.column_dimensions[col].width = 15
|
||
ws.column_dimensions["I"].width = 30
|
||
return ws
|
||
|
||
|
||
# --------------------------------------------------------------------------
|
||
# Assumptions sheet
|
||
# --------------------------------------------------------------------------
|
||
|
||
def write_assumptions(wb, model):
|
||
cfg, spec = model["cfg"], model["spec"]
|
||
ws = wb.create_sheet("Assumptions")
|
||
ws.sheet_view.showGridLines = False
|
||
ws["A1"] = f"Model {spec['key']} — Assumptions"
|
||
ws["A1"].font = TITLE_FONT
|
||
ws.column_dimensions["A"].width = 44
|
||
ws.column_dimensions["B"].width = 22
|
||
ws.column_dimensions["C"].width = 54
|
||
|
||
r = 3
|
||
ad = cfg["ad_revenue"]
|
||
|
||
def kv(label, value, note="", fmt=None):
|
||
nonlocal r
|
||
ws.cell(row=r, column=1, value=label).font = LABEL_FONT
|
||
c = ws.cell(row=r, column=2, value=value)
|
||
if fmt:
|
||
c.number_format = fmt
|
||
ws.cell(row=r, column=3, value=note).font = Font(size=9, color="666666")
|
||
r += 1
|
||
|
||
_band(ws, r, "Advertising Revenue (per proposal)", 3); r += 1
|
||
for k, label, fmt in [("screen_count", "Screens in proposal", "#,##0"),
|
||
("monthly_onboardings", "Monthly on-boardings", "#,##0"),
|
||
("journey_minutes", "Avg journey time (min)", "0.0"),
|
||
("ad_slots", "15-second ad slots", "#,##0"),
|
||
("monthly_impressions", "Total monthly impressions", "#,##0"),
|
||
("fill_rate", "Assumed blended fill rate", PCT)]:
|
||
if k in ad:
|
||
kv(label, ad[k], "", fmt)
|
||
kv("Gross monthly ad revenue", ad["monthly_gross"], "Steady-state total", MONEY)
|
||
kv("Gross annual ad revenue", ad.get("annual_gross", ad["monthly_gross"] * 12), "", MONEY)
|
||
r += 1
|
||
|
||
if ad.get("sources"):
|
||
_band(ws, r, "Revenue Sources", 3); r += 1
|
||
for s in ad["sources"]:
|
||
ws.cell(row=r, column=1, value=s["name"])
|
||
c = ws.cell(row=r, column=2, value=s["monthly"]); c.number_format = MONEY
|
||
bits = []
|
||
if s.get("cpm"):
|
||
bits.append(f"CPM ${s['cpm']:.2f}")
|
||
if s.get("fill"):
|
||
bits.append(f"{s['fill']:.0%} fill")
|
||
ws.cell(row=r, column=3, value=", ".join(bits)).font = Font(size=9, color="666666")
|
||
r += 1
|
||
r += 1
|
||
|
||
_band(ws, r, "Revenue Split", 3); r += 1
|
||
for p, s in spec["shares"].items():
|
||
kv(p, s, "", PCT)
|
||
r += 1
|
||
|
||
_band(ws, r, "Model Parameters", 3); r += 1
|
||
kv("Horizon", f"{model['horizon']} months")
|
||
kv("Ramp length", f"{cfg.get('ramp_months', 12)} months",
|
||
"Linear ramp reflecting the proposal's fill-rate caveat")
|
||
kv("Month-1 revenue", cfg.get("ramp_start_pct", 0.25),
|
||
"Fraction of steady-state at launch", PCT)
|
||
fin = model["finance"]
|
||
if fin["active"]:
|
||
kv("Capital financed by", "MPM", "Principal is MPM's one-time COGS outlay")
|
||
kv("Principal", fin["principal"], "", MONEY)
|
||
kv("Annual cost of money", fin["rate"],
|
||
"Interest accrues monthly on the declining balance", PCT)
|
||
kv("Debt service", "MPM share, interest first",
|
||
"Milestones clear only after capital and accrued interest are recovered")
|
||
else:
|
||
kv("Capital financed by",
|
||
"Customer" if spec["key"] == "2C" else "MPM",
|
||
"No interest modeled — " + ("the customer purchased the system outright"
|
||
if spec["key"] == "2C"
|
||
else "this variant is revenue-only"))
|
||
kv("Recurring licensing borne by", model["recurring_bearer"],
|
||
f"${model['monthly_recurring']:,.2f}/mo at "
|
||
f"{'vendor cost' if model['recurring_bearer'] == 'MPM' else 'invoiced price'}")
|
||
kv("Client contribution",
|
||
sum(c["amount"] for c in cfg.get("client_contributions", [])) or 0,
|
||
"Deposits or milestone payments offsetting financed capital", MONEY)
|
||
r += 1
|
||
|
||
_band(ws, r, "Exclusions and Caveats", 3); r += 1
|
||
notes = list(cfg.get("notes", []))
|
||
for s in cfg.get("surges", []):
|
||
if not s.get("enabled"):
|
||
notes.append(f"{s.get('label', 'Event surge')} excluded from base model "
|
||
f"(${s['total']:,.0f} over {s['months']} months) — treated as upside.")
|
||
notes.append("Ad revenue is a forecast, not a contracted receivable. Fill rates may be "
|
||
"materially lower until repeat advertisers and programmatic demand establish.")
|
||
if spec["milestones"]:
|
||
notes.append("Payoff targets represent the one-time capital at risk. Recurring "
|
||
"licensing runs as an ongoing monthly charge for the full horizon.")
|
||
if spec["key"] == "2C":
|
||
notes.append("The End User purchased the system, so the MSRP milestone measures the "
|
||
"customer's own payback from their 70% share — not MPM's return.")
|
||
notes.append("This model pairs one advertising proposal with one sales order. Its revenue "
|
||
"figures are not transferable to any other deployment.")
|
||
for n in notes:
|
||
ws.cell(row=r, column=1, value="• " + n).font = Font(size=9)
|
||
ws.merge_cells(start_row=r, start_column=1, end_row=r, end_column=3)
|
||
ws.cell(row=r, column=1).alignment = Alignment(wrap_text=True, vertical="top")
|
||
ws.row_dimensions[r].height = 28
|
||
r += 1
|
||
return ws
|
||
|
||
|
||
# --------------------------------------------------------------------------
|
||
|
||
def build_workbook(cfg, model_key, path):
|
||
model = build_model(cfg, model_key)
|
||
wb = Workbook()
|
||
wb.remove(wb.active)
|
||
write_summary(wb, model)
|
||
write_projection(wb, model)
|
||
if model["spec"]["show_cost_basis"]:
|
||
write_cost_basis(wb, model)
|
||
write_assumptions(wb, model)
|
||
wb.save(path)
|
||
return model
|
||
|
||
|
||
def recap(model, path):
|
||
spec, fin = model["spec"], model["finance"]
|
||
last = model["rows"][-1]
|
||
print(f"\n{os.path.basename(path)} — Model {spec['key']}: {spec['title']}")
|
||
print(" split: " + ", ".join(f"{p} {s:.1%}" for p, s in spec["shares"].items()))
|
||
print(f" {model['horizon']}-mo distribution: " +
|
||
", ".join(f"{p} ${last['cum_parties'][p]:,.0f}" for p in model["parties"]))
|
||
if fin["active"]:
|
||
print(f" financed ${fin['principal']:,.2f} @ {fin['rate']:.1%} → "
|
||
f"interest ${fin['total_interest']:,.2f}")
|
||
if fin["neg_amort_months"]:
|
||
print(f" !! negative amortization months "
|
||
f"{fin['neg_amort_months'][0]}–{fin['neg_amort_months'][-1]}")
|
||
for key in spec["milestones"]:
|
||
hit = model["crossings"][key]
|
||
print(f" {MILESTONE_LABEL[key]:<10} ${model['targets'][key]:>11,.2f} → "
|
||
f"{'month ' + str(hit) if hit else 'not reached'}")
|
||
if not spec["milestones"]:
|
||
print(" (revenue distribution only — no cost basis or milestones)")
|
||
|
||
|
||
def main():
|
||
ap = argparse.ArgumentParser()
|
||
ap.add_argument("config")
|
||
ap.add_argument("--model", "-m", default="all", choices=["2A", "2B", "2C", "all"])
|
||
ap.add_argument("-o", "--output", help="Output path (single model only)")
|
||
ap.add_argument("--outdir", "-d", default=".", help="Directory for --model all")
|
||
ap.add_argument("--prefix", default=None, help="Filename prefix; defaults to the sales order")
|
||
args = ap.parse_args()
|
||
|
||
with open(args.config) as f:
|
||
cfg = json.load(f)
|
||
|
||
keys = ["2A", "2B", "2C"] if args.model == "all" else [args.model]
|
||
prefix = args.prefix or cfg.get("sale_order", "cap_table")
|
||
slug = {"2A": "2A_Internal_MPM_Financed_ROI",
|
||
"2B": "2B_Internal_MPM_Financed_Revenue",
|
||
"2C": "2C_Customer_Financed_Acquisition"}
|
||
|
||
p = None
|
||
for key in keys:
|
||
if args.output and len(keys) == 1:
|
||
path = args.output
|
||
else:
|
||
os.makedirs(args.outdir, exist_ok=True)
|
||
path = os.path.join(args.outdir, f"{prefix}_{slug[key]}.xlsx")
|
||
model = build_workbook(cfg, key, path)
|
||
recap(model, path)
|
||
p = model["pairing"]
|
||
|
||
if p and p["proposal"] and p["quote"] and not p["ok"]:
|
||
print(f"\n!! SCREEN COUNT MISMATCH: proposal {p['proposal']:g} vs quote "
|
||
f"{p['quote']:g} — verify these describe the same deployment")
|
||
elif p and not (p["proposal"] and p["quote"]):
|
||
print("\n.. screen count not reconciled (set ad_revenue.screen_count and "
|
||
"is_display on the display line)")
|
||
return 0
|
||
|
||
|
||
if __name__ == "__main__":
|
||
sys.exit(main())
|