try:

return int(d.get(k, 0) or 0)

except (TypeError, ValueError):

try:

return float(d.get(k, 0) or 0)

except (TypeError, ValueError):

"""Flatten one ``usageEventsDisplay`` entry into a plain dict."""

tu = ev.get("tokenUsage") or {}

ts_ms = _i(ev, "timestamp")

local = datetime.fromtimestamp(ts_ms / 1000).astimezone() if ts_ms else None

return OrderedDict([

("datetime_local", local.isoformat() if local else ""),

("timestamp_ms", ts_ms),

("date", local.strftime("%Y-%m-%d") if local else ""),

("model", ev.get("model", "")),

("kind", ev.get("kind", "")),

("input_tokens", _i(tu, "inputTokens")),

("output_tokens", _i(tu, "outputTokens")),

("cache_read_tokens", _i(tu, "cacheReadTokens")),

("cache_write_tokens", _i(tu, "cacheWriteTokens")),

("value_cents", round(_f(tu, "totalCents"), 6)),

("charged_cents", round(_f(ev, "chargedCents"), 6)),

("requests_costs", ev.get("requestsCosts", 0)),

("is_headless", bool(ev.get("isHeadless", False))),

("owning_user", ev.get("owningUser", "")),

rows = agg.get("aggregations", []) or []

cents = lambda r: _f(r, "totalCents")

total = sum(cents(r) for r in rows)

ti = sum(_i(r, "inputTokens") for r in rows)

to = sum(_i(r, "outputTokens") for r in rows)

tcr = sum(_i(r, "cacheReadTokens") for r in rows)

tcw = sum(_i(r, "cacheWriteTokens") for r in rows)

out = ["=" * 78]

out.append("CURSOR USAGE | %s | %s -> %s"

% (meta["email"], meta["start"], meta["end"]))

out.append("=" * 78)

out.append("Included value used : %s (compute consumed; included in plan)" % _money(total))

out.append("Tokens in=%s out=%s" % (_n(ti), _n(to)))

out.append(" cacheRead=%s cacheWrite=%s" % (_n(tcr), _n(tcw)))

out.append(_rule())

out.append("%-36s%10s%14s%12s" % ("model", "$ value", "in tok", "out tok"))

out.append(_rule())

for r in sorted(rows, key=lambda x: -cents(x)):

out.append("%-36s%10s%14s%12s" % (

r.get("modelIntent", "?"),

format(cents(r) / 100.0, ",.2f"),

_n(_i(r, "inputTokens")),

_n(_i(r, "outputTokens")),

))

days = OrderedDict()

for ev in events:

row = event_row(ev)

d = row["date"] or "unknown"

b = days.setdefault(d, {"n": 0, "in": 0, "out": 0, "cents": 0.0})

b["n"] += 1

b["in"] += row["input_tokens"]

b["out"] += row["output_tokens"]

b["cents"] += row["value_cents"]

out = ["=" * 78]

out.append("CURSOR USAGE BY DAY | %s | %s -> %s"

% (meta["email"], meta["start"], meta["end"]))

out.append("=" * 78)

out.append("%-12s%9s%12s%15s%13s" % ("date", "events", "$ value", "in tok", "out tok"))

out.append(_rule())

tot = {"n": 0, "in": 0, "out": 0, "cents": 0.0}

for d in sorted(days):

b = days[d]

out.append("%-12s%9s%12s%15s%13s" % (

d, _n(b["n"]), format(b["cents"] / 100.0, ",.2f"), _n(b["in"]), _n(b["out"])))

for k in tot:

tot[k] += b[k]

out.append(_rule())

out.append("%-12s%9s%12s%15s%13s" % (

"TOTAL", _n(tot["n"]), format(tot["cents"] / 100.0, ",.2f"),

_n(tot["in"]), _n(tot["out"])))

rows = [event_row(e) for e in events]

rows.sort(key=lambda r: r["timestamp_ms"])

fields = list(event_row({}).keys())

with open(path, "w", newline="", encoding="utf-8") as fh:

writer = csv.DictWriter(fh, fieldnames=fields)

writer.writeheader()

writer.writerows(rows)

if k not in d:

return None

try:

v = d[k]

if v is None:

return None

return float(v or 0)

except (TypeError, ValueError):

if k not in d:

return None

try:

v = d[k]

if v is None:

return None

return int(v or 0)

except (TypeError, ValueError):

raw = payload.get("billingCycleEnd")

if raw is None:

return None

try:

s = str(raw).strip()

if s.isdigit():

ms = int(s)

return datetime.fromtimestamp(ms / 1000, tz=timezone.utc).strftime(

"%Y-%m-%d")

return datetime.fromisoformat(s.replace("Z", "+00:00")).strftime(

"%Y-%m-%d")

except (TypeError, ValueError, OSError):

if pct is None:

return None

bar = _limit_bar(pct)

left = max(0.0, 100.0 - pct)

"""Render cycle-limit % bars and included-usage dollars, or None."""

if not payload or not isinstance(payload, dict):

return None

plan = (payload.get("planUsage")

or (payload.get("individualUsage") or {}).get("plan")

or {})

enabled = payload.get("enabled", plan.get("enabled", True))

if not enabled:

return None

is_unlimited = bool(payload.get("isUnlimited"))

auto_pct = _optional_f(plan, "autoPercentUsed")

api_pct = _optional_f(plan, "apiPercentUsed")

used = None

if "totalSpend" in plan:

used = _optional_i(plan, "totalSpend")

if used is None and "used" in plan:

used = _optional_i(plan, "used")

limit = _optional_i(plan, "limit") if "limit" in plan else None

remaining = None

if "remaining" in plan:

remaining = _optional_i(plan, "remaining")

if remaining is None and limit is not None and used is not None:

remaining = max(0, limit - used)

money_line = None

if limit is not None and limit > 0 and used is not None and remaining is not None:

money_line = "%-16s%s of %s used (%s left)" % (

"Included usage", _money(used), _money(limit), _money(remaining))

if (not is_unlimited and auto_pct is None and api_pct is None

and not money_line):

return None

reset = _parse_reset_date(payload)

out = ["=" * 78]

header = "CURSOR CYCLE LIMITS"

if reset:

header += " | resets %s" % reset

out.append(header)

out.append("=" * 78)

if is_unlimited:

out.append("Plan reports unlimited usage for this cycle.")

if money_line:

out.append(money_line)

return "\n".join(out)

for label, pct in [("Composer / Auto", auto_pct),

("Other models", api_pct)]:

line = _limit_bucket_line(label, pct)

if line:

out.append(line)

if money_line:

out.append(money_line)

if len(out) <= 3:

return None