File size: 7,570 Bytes
dcef129 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 | """Finance: answer an accounts-receivable question by querying a read-only SQLite database."""
import datetime as dt
import math
import sqlite3
from typing import Any, Literal
from pydantic import Field
from ..core import Action, ProxyTask, Step, clip
CUSTOMERS = ["Arcturus Labs", "Birchwood Foods", "Cobalt Freight", "Delta Optics", "Evergreen Clinics",
"Fjord Marine", "Granite Legal", "Helios Solar"]
FX = {"USD": 1.0, "EUR": 1.08, "GBP": 1.27, "CAD": 0.73}
class LedgerAction(Action):
type: Literal["query", "answer"] = Field(
description="query: run one read-only SQL statement (SQLite) in `sql`. answer: submit `answer`, which "
"ends the episode.")
sql: str = Field(default="", description="A single SELECT statement.")
answer: dict[str, Any] = Field(default_factory=dict, description="Final answer object.")
class Receivables(ProxyTask):
family = "finance-receivables"
domain = "finance-economics"
Action = LedgerAction
max_steps = 10
finish_action = {"type": "answer", "answer": {}}
def setup(self):
r = self.rng
self.as_of = dt.date(2026, 9, 30)
self.variant = self.seed % 2
self.db = sqlite3.connect(":memory:", check_same_thread=False)
c = self.db
c.executescript("""
CREATE TABLE customers (id INTEGER PRIMARY KEY, name TEXT, country TEXT);
CREATE TABLE invoices (id INTEGER PRIMARY KEY, customer_id INTEGER, issued TEXT, due TEXT,
amount REAL, currency TEXT, status TEXT);
CREATE TABLE payments (id INTEGER PRIMARY KEY, invoice_id INTEGER, paid_on TEXT, amount REAL);
CREATE TABLE fx_rates (currency TEXT PRIMARY KEY, usd_per_unit REAL);
""")
for i, name in enumerate(CUSTOMERS, 1):
c.execute("INSERT INTO customers VALUES (?,?,?)", (i, name, r.choice(["US", "DE", "UK", "CA"])))
c.executemany("INSERT INTO fx_rates VALUES (?,?)", FX.items())
inv_id, pay_id = 1000, 1
self.invoices, self.payments = [], []
for _ in range(r.randint(40, 60)):
cust = r.randint(1, len(CUSTOMERS))
issued = self.as_of - dt.timedelta(days=r.randint(5, 200))
due = issued + dt.timedelta(days=r.choice([30, 45, 60]))
amount = round(r.uniform(400, 25000), 2)
cur = r.choice(list(FX))
status = r.choices(["open", "void"], [0.92, 0.08])[0]
inv_id += 1
self.invoices.append((inv_id, cust, issued.isoformat(), due.isoformat(), amount, cur, status))
if status == "void":
continue
paid = r.choice([0, 0, amount, round(amount * r.uniform(0.2, 0.8), 2)])
if paid:
when = issued + dt.timedelta(days=r.randint(3, 120))
if when <= self.as_of:
self.payments.append((pay_id, inv_id, when.isoformat(), paid))
pay_id += 1
if r.random() < 0.12: # an accidental duplicate payment a day or two later
self.payments.append((pay_id, inv_id, (when + dt.timedelta(days=r.randint(1, 2))).isoformat(), paid))
pay_id += 1
c.executemany("INSERT INTO invoices VALUES (?,?,?,?,?,?,?)", self.invoices)
c.executemany("INSERT INTO payments VALUES (?,?,?,?)", self.payments)
c.execute("PRAGMA query_only = ON")
self.answer = self._truth()
def _truth(self):
paid = {}
for _, inv, _, amt in self.payments:
paid[inv] = paid.get(inv, 0) + amt
if self.variant == 0:
per_cust = {}
for inv, cust, _, due, amt, cur, status in self.invoices:
overdue_days = (self.as_of - dt.date.fromisoformat(due)).days
bal = amt - paid.get(inv, 0)
if status == "open" and overdue_days > 60 and bal > 0.005:
per_cust[cust] = per_cust.get(cust, 0) + bal * FX[cur]
assert len(per_cust) >= 2
top = max(per_cust, key=per_cust.get)
ranked = sorted(per_cust.values())
assert ranked[-1] - ranked[-2] > 50
self.question = ("As of 2026-09-30, what is the total outstanding balance in USD of open (not void) "
"invoices more than 60 days past their due date, and which customer owes the most of "
"it? Outstanding = invoice amount minus all payments on it; convert with fx_rates.")
return {"total_usd": round(sum(per_cust.values()), 2), "top_customer": CUSTOMERS[top - 1]}
groups = {}
for pid, inv, when, amt in self.payments:
groups.setdefault((inv, amt), []).append(dt.date.fromisoformat(when))
dups, excess = 0, 0.0
cur = {i[0]: i[5] for i in self.invoices}
for (inv, amt), dates in groups.items():
dates.sort()
for prev, nxt in zip(dates, dates[1:]):
if (nxt - prev).days <= 3:
dups += 1
excess += amt * FX[cur[inv]]
assert dups >= 1
self.question = ("Find duplicate payments: a payment is a duplicate when the same invoice already received "
"a payment of exactly the same amount within the previous 3 days. How many duplicate "
"payments are there, and what is their total in USD (convert with fx_rates)?")
return {"duplicate_count": dups, "duplicate_total_usd": round(excess, 2)}
def reset(self):
keys = ", ".join(f'"{k}"' for k in self.answer)
return {"output": f"Accounts receivable database (SQLite, read-only). Tables: customers, invoices, "
f"payments, fx_rates. {self.question} Answer with an object with keys {keys}; amounts "
f"are checked to the cent (within $1.00).",
"queries_left": self.max_steps}
def act(self, a):
left = self.max_steps - self.steps
if a.type == "query":
try:
cur = self.db.execute(a.sql)
cols = [d[0] for d in cur.description or []]
rows = cur.fetchmany(80)
more = len(cur.fetchall())
text = "\t".join(cols) + "\n" + "\n".join("\t".join(map(str, row)) for row in rows)
if more:
text += f"\n... {more} more rows"
except sqlite3.Error as exc:
text = f"SQL error: {exc}"
return Step({"output": clip(text, 3500), "queries_left": left})
got = {str(k).lower(): v for k, v in a.answer.items()}
ok = True
for key, want in self.answer.items():
val = got.get(key.lower())
if isinstance(want, str):
ok &= isinstance(val, str) and val.strip().lower() == want.lower()
elif isinstance(want, int):
ok &= isinstance(val, (int, float)) and not isinstance(val, bool) and val == want
else:
try:
num = float(str(val).replace("$", "").replace(",", ""))
ok &= math.isfinite(num) and abs(num - want) <= 1.0
except ValueError:
ok = False
return Step({"output": "Answer recorded.", "queries_left": 0}, True, 1.0 if ok else 0.0)
def oracle(self):
return [{"type": "query", "sql": "SELECT name FROM sqlite_master"},
{"type": "answer", "answer": self.answer}]
|