#!/usr/bin/env python3 """Kaggle GPU usage ledger. Kaggle gives each account ~30 GPU-hours per week, 2 concurrent sessions. The number that matters is not "did it finish" but "how many GPU seconds did it cost", and nobody was tracking it. # record a finished run by hand python scripts/kaggle_usage.py log --kernel yamahei21python/uzu-eval-4b-rtn-probe \ --account owner --seconds 5420 --gpu T4x2 --note "4B RTN eval v3" # or track it until it stops python scripts/kaggle_usage.py track --kernel yamahei21python/uzu-emb8-08b-gpu --account owner # weekly report against the quota python scripts/kaggle_usage.py report --week 2026-W45 --quota-hours 30 The ledger is JSON Lines so a crashed run cannot corrupt it. """ from __future__ import annotations import argparse import json import subprocess import time from datetime import date, datetime from pathlib import Path from typing import Any ROOT = Path(__file__).resolve().parents[1] LEDGER = ROOT / "logs" / "kaggle_usage.jsonl" TERMINAL = ("COMPLETE", "ERROR", "FAILED", "CANCEL", "CANCELLED") def week_key(value: date) -> str: year, week, _ = value.isocalendar() return f"{year}-W{week:02d}" def is_terminal(status: str) -> bool: upper = status.upper() return any(marker in upper for marker in TERMINAL) def append_entry(ledger: Path, entry: dict[str, Any]) -> None: ledger.parent.mkdir(parents=True, exist_ok=True) with ledger.open("a", encoding="utf-8") as handle: handle.write(json.dumps(entry, ensure_ascii=False) + "\n") def read_entries(ledger: Path) -> list[dict[str, Any]]: if not ledger.exists(): return [] entries = [] for line in ledger.read_text(encoding="utf-8").splitlines(): line = line.strip() if not line: continue try: entries.append(json.loads(line)) except json.JSONDecodeError: continue return entries def summarize(entries: list[dict[str, Any]], week: str, quota_hours: float) -> dict[str, Any]: filtered = [entry for entry in entries if entry.get("week") == week] by_account: dict[str, dict[str, Any]] = {} for entry in filtered: account = entry.get("account", "unknown") bucket = by_account.setdefault(account, {"runs": 0, "seconds": 0.0, "kernels": []}) bucket["runs"] += 1 bucket["seconds"] += float(entry.get("seconds", 0)) bucket["kernels"].append(entry.get("kernel")) quota_seconds = quota_hours * 3600 for account, bucket in by_account.items(): bucket["hours"] = round(bucket["seconds"] / 3600, 2) bucket["remaining_hours"] = round((quota_seconds - bucket["seconds"]) / 3600, 2) bucket["used_pct"] = round(100 * bucket["seconds"] / quota_seconds, 1) if quota_seconds else None total_seconds = sum(bucket["seconds"] for bucket in by_account.values()) return { "week": week, "quota_hours_per_account": quota_hours, "accounts": by_account, "total_hours": round(total_seconds / 3600, 2), "runs": len(filtered), } def format_report(summary: dict[str, Any]) -> str: lines = [ f"week {summary['week']} quota {summary['quota_hours_per_account']}h/account runs {summary['runs']}", f"{'account':10s} {'hours':>8s} {'left':>8s} {'used':>7s} kernels", "-" * 72, ] for account, bucket in sorted(summary["accounts"].items()): kernels = ", ".join(str(name) for name in bucket["kernels"][-3:]) lines.append( f"{account:10s} {bucket['hours']:8.2f} {bucket['remaining_hours']:8.2f} " f"{(bucket['used_pct'] or 0):6.1f}% {kernels}" ) return "\n".join(lines) def kernel_status(kernel: str) -> str: result = subprocess.run( ["kaggle", "kernels", "status", kernel], text=True, capture_output=True, check=False ) text = (result.stdout or "") + (result.stderr or "") for line in text.splitlines(): if "status" in line.lower(): return line.strip() return text.strip() def track(kernel: str, account: str, interval: float, ledger: Path) -> dict[str, Any]: started = time.time() status = "" while True: status = kernel_status(kernel) if is_terminal(status): break print(f"{time.strftime('%H:%M:%S')} {status}", flush=True) time.sleep(interval) entry = { "kernel": kernel, "account": account, "seconds": round(time.time() - started, 1), "status": status, "week": week_key(date.today()), "finished": datetime.now().isoformat(timespec="seconds"), "note": "tracked", } append_entry(ledger, entry) return entry def main() -> None: parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) parser.add_argument("--ledger", type=Path, default=LEDGER) sub = parser.add_subparsers(dest="command", required=True) log = sub.add_parser("log") log.add_argument("--kernel", required=True) log.add_argument("--account", default="owner") log.add_argument("--seconds", type=float, required=True) log.add_argument("--gpu", default="T4x2") log.add_argument("--week", default=None) log.add_argument("--note", default="") track_cmd = sub.add_parser("track") track_cmd.add_argument("--kernel", required=True) track_cmd.add_argument("--account", default="owner") track_cmd.add_argument("--interval", type=float, default=60.0) report = sub.add_parser("report") report.add_argument("--week", default=None) report.add_argument("--quota-hours", type=float, default=30.0) report.add_argument("--json", type=Path, default=None) args = parser.parse_args() if args.command == "log": entry = { "kernel": args.kernel, "account": args.account, "seconds": args.seconds, "gpu": args.gpu, "week": args.week or week_key(date.today()), "logged": datetime.now().isoformat(timespec="seconds"), "note": args.note, } append_entry(args.ledger, entry) print(json.dumps(entry, ensure_ascii=False)) elif args.command == "track": entry = track(args.kernel, args.account, args.interval, args.ledger) print(json.dumps(entry, ensure_ascii=False)) else: week = args.week or week_key(date.today()) summary = summarize(read_entries(args.ledger), week, args.quota_hours) print(format_report(summary)) if args.json: args.json.parent.mkdir(parents=True, exist_ok=True) args.json.write_text(json.dumps(summary, indent=2, ensure_ascii=False) + "\n", encoding="utf-8") print(f"wrote {args.json}") if __name__ == "__main__": main()