21Trade Capture and Booking

class TradeStore:
    """Event-sourced trades: the log is the truth, states are replays."""

    def __init__(self):
        self.log: list[Event] = []

    def apply(self, e: Event) -> None:
        if e.kind not in KINDS:
            raise ValueError(f"unknown event {e.kind}")
        if e.kind != "new" and self.as_of(e.trade_id, e.ts) is None:
            raise ValueError(f"{e.kind} on a trade that does not exist: {e.trade_id}")
        self.log.append(e)

    def as_of(self, trade_id: str, ts: float | None = None) -> dict | None:
        state = None
        mine = sorted((x for x in self.log if x.trade_id == trade_id), key=lambda x: x.ts)
        for e in mine:
            if ts is not None and e.ts > ts:
                break
            state = _step(state, e)
        return state

    def versions(self, trade_id: str) -> list[tuple]:
        out, state = [], None
        mine = sorted((x for x in self.log if x.trade_id == trade_id), key=lambda x: x.ts)
        for e in mine:
            state = _step(state, e)
            out.append((e.ts, state["version"]))
        return out

def _step(state, e: Event) -> dict:
    if e.kind == "new":
        s = copy.deepcopy(e.data)
        s.update(version=1, status="live")
        return s
    s = copy.deepcopy(state)
    s["version"] += 1
    if e.kind == "amend":
        s.update(e.data)
    elif e.kind == "novate":                         # a party steps out, another steps in
        s[e.data["side"]] = e.data["new"]
    elif e.kind == "terminate":                  # partial termination: the quantity falls
        s["quantity"] -= e.data["quantity"]
        if s["quantity"] <= 0:
            s["status"] = "terminated"
    elif e.kind == "exercise":
        s["status"] = "exercised"
        s["instrument"] = e.data["into"]
    elif e.kind == "cancel":
        s["status"] = "cancelled"
    elif e.kind == "allocate":
        s["status"] = "allocated"
        s["allocations"] = e.data["allocations"]
    return s

POLICIES = {                  # what each copy-based system copies, and when
    "risk": ("nightly", None),                          # every trade at 18:00, every day
    "confirmation": ("on", {"new", "amend"}),           # a copy on the events it confirms
    "settlement": ("on", {"new", "terminate"}),         # a copy on the events that move cash
}


def downstream(store: T.TradeStore, events: list, at: float = 4 * DAY + 15 * HOUR,
               hours=(18,)) -> dict:
    ids = sorted({e.trade_id for e in events})
    nights = [d * DAY + h * HOUR for d in range(5) for h in hours if d * DAY + h * HOUR <= at]
    views = {}
    for name, (how, kinds) in POLICIES.items():
        v = {}
        for tid in ids:
            if how == "nightly":
                v[tid] = store.as_of(tid, max(nights))
            else:
                copies = [e.ts for e in events
                          if e.trade_id == tid and e.kind in kinds and e.ts <= at]
                v[tid] = store.as_of(tid, max(copies)) if copies else None
        views[name] = v
    golden = {tid: store.as_of(tid, at) for tid in ids}
    wrong = {name: sum(views[name][t] != golden[t] for t in ids) for name in views}
    disagree = sum(len({repr(views[n][t]) for n in views}) > 1 for t in ids)
    return {"wrong": wrong, "disagree": disagree, "golden": golden, "views": views,
            "n": len(ids)}

def allocate(fills, weights: dict, rule: str = "largest-remainder", lot: int = 1):
    """Split a block among funds at its average price, in whole lots; the rule decides where
    the lots that do not divide go. Returns the allocations and the residual."""
    total = sum(q for q, _ in fills)
    avg = sum(q * p for q, p in fills) / total
    lots = total // lot
    wsum = sum(weights.values())
    exact = {f: lots * w / wsum for f, w in weights.items()}
    if rule == "round-each":
        n = {f: int(math.floor(x + 0.5)) for f, x in exact.items()}
    else:
        n = {f: int(math.floor(x)) for f, x in exact.items()}
        left = lots - sum(n.values())
        if rule == "largest-remainder":
            order = sorted(exact, key=lambda f: (-(exact[f] - n[f]), f))
        elif rule == "floor-then-largest":
            order = sorted(exact, key=lambda f: (-weights[f], f))
        else:
            raise ValueError(rule)
        for f in order[:left]:
            n[f] += 1
    alloc = {f: (k * lot, avg) for f, k in n.items()}
    return alloc, total - sum(q for q, _ in alloc.values())