Datasets:

jwu323
/

FlowBench

@@ -1,311 +0,0 @@
-"""Deterministic FlowBench v3 tools. This file contains no task answers."""
-REGIONS = ["NA", "EU", "APAC", "LATAM"]
-CATEGORIES = ["A", "B", "C", "D"]
-CURRENCIES = {"NA": "USD", "EU": "EUR", "APAC": "JPY", "LATAM": "BRL"}
-FX_TO_USD_BP = {"USD": 10000, "EUR": 10900, "JPY": 67, "BRL": 1850}
-TIERS = ["std", "gold", "plat"]
-DISCOUNT_PCT = {"std": 0, "gold": 10, "plat": 20}
-CHANNELS = ["web", "store", "partner"]
-MONTHS = [202601, 202602, 202603, 202604, 202605, 202606]
-N_CUSTOMERS = 72
-N_PRODUCTS = 48
-N_ORDERS = 720
-N_TICKETS = 260
-N_RETURNS = 180
-def _h(*xs):
-    import hashlib
-    s = "|".join(str(x) for x in xs).encode()
-    return int.from_bytes(hashlib.sha256(s).digest()[:8], "big") & 0x7FFFFFFF
-def build_data():
-    customers = []
-    for cid in range(N_CUSTOMERS):
-        region = REGIONS[_h("region", cid) % len(REGIONS)]
-        customers.append({
-            "customer_id": cid,
-            "region": region,
-            "tier": TIERS[_h("tier", cid) % len(TIERS)],
-            "segment": ["consumer", "smb", "enterprise"][_h("segment", cid) % 3],
-        })
-    products = []
-    for pid in range(N_PRODUCTS):
-        cat = CATEGORIES[_h("cat", pid) % len(CATEGORIES)]
-        unit_price = 12 + _h("price", pid) % 240
-        cogs = unit_price * (45 + _h("margin", pid) % 35) // 100
-        products.append({
-            "product_id": pid,
-            "category": cat,
-            "unit_price_usd": unit_price,
-            "unit_cogs_usd": cogs,
-            "lead_time_days": 3 + _h("lead", pid) % 18,
-        })
-    inventory = []
-    for pid in range(N_PRODUCTS):
-        for region in REGIONS:
-            inventory.append({
-                "product_id": pid,
-                "region": region,
-                "on_hand": 10 + _h("onhand", pid, region) % 140,
-                "reserved": _h("reserved", pid, region) % 28,
-                "inbound": _h("inbound", pid, region) % 85,
-            })
-    orders = []
-    for oid in range(N_ORDERS):
-        customer_id = _h("ocust", oid) % N_CUSTOMERS
-        product_id = _h("oprod", oid) % N_PRODUCTS
-        month = MONTHS[_h("month", oid) % len(MONTHS)]
-        qty = 1 + _h("qty", oid) % 9
-        ship_days = 1 + _h("shipdays", oid) % 16
-        promised_days = 3 + _h("promise", oid) % 9
-        status = ["paid", "paid", "paid", "paid", "cancelled", "refunded"][
-            _h("status", oid) % 6]
-        orders.append({
-            "order_id": oid,
-            "customer_id": customer_id,
-            "product_id": product_id,
-            "month": month,
-            "qty": qty,
-            "status": status,
-            "channel": CHANNELS[_h("channel", oid) % len(CHANNELS)],
-            "ship_days": ship_days,
-            "promised_days": promised_days,
-        })
-    returns = []
-    for rid in range(N_RETURNS):
-        oid = _h("roid", rid) % N_ORDERS
-        order = orders[oid]
-        if order["status"] == "cancelled":
-            continue
-        returned_qty = 1 + _h("rqty", rid) % max(1, order["qty"])
-        reason = ["defect", "late", "changed_mind", "wrong_item"][_h("reason", rid) % 4]
-        returns.append({
-            "return_id": rid,
-            "order_id": oid,
-            "month": MONTHS[_h("rmonth", rid) % len(MONTHS)],
-            "returned_qty": returned_qty,
-            "reason": reason,
-        })
-    tickets = []
-    for tid in range(N_TICKETS):
-        oid = _h("toid", tid) % N_ORDERS
-        severity = ["low", "medium", "high", "critical"][_h("sev", tid) % 4]
-        opened = MONTHS[_h("tmonth", tid) % len(MONTHS)]
-        first_response_hours = 1 + _h("resp", tid) % 96
-        resolution_hours = first_response_hours + _h("res", tid) % 240
-        tickets.append({
-            "ticket_id": tid,
-            "order_id": oid,
-            "opened_month": opened,
-            "severity": severity,
-            "first_response_hours": first_response_hours,
-            "resolution_hours": resolution_hours,
-        })
-    return {
-        "customers": customers,
-        "products": products,
-        "inventory": inventory,
-        "orders": orders,
-        "returns": returns,
-        "tickets": tickets,
-        "fx_to_usd_bp": FX_TO_USD_BP,
-    }
-DATA = build_data()
-CUSTOMERS = {c["customer_id"]: c for c in DATA["customers"]}
-PRODUCTS = {p["product_id"]: p for p in DATA["products"]}
-ORDERS = {o["order_id"]: o for o in DATA["orders"]}
-def region_currency(region: str) -> str:
-    return CURRENCIES[region]
-def get_orders(region: str, category: str, month_start: int, month_end: int) -> list:
-    """Paid/refunded order ids in a region/category/month window."""
-    out = []
-    for o in DATA["orders"]:
-        if o["status"] not in ("paid", "refunded"):
-            continue
-        c = CUSTOMERS[o["customer_id"]]
-        p = PRODUCTS[o["product_id"]]
-        if c["region"] == region and p["category"] == category and month_start <= o["month"] <= month_end:
-            out.append(o["order_id"])
-    return sorted(out)
-def order_gross_usd(order_id: int) -> int:
-    o = ORDERS[order_id]
-    p = PRODUCTS[o["product_id"]]
-    return o["qty"] * p["unit_price_usd"]
-def order_margin_usd(order_id: int) -> int:
-    o = ORDERS[order_id]
-    p = PRODUCTS[o["product_id"]]
-    return o["qty"] * (p["unit_price_usd"] - p["unit_cogs_usd"])
-def refund_usd(order_id: int) -> int:
-    o = ORDERS[order_id]
-    p = PRODUCTS[o["product_id"]]
-    qty = sum(r["returned_qty"] for r in DATA["returns"] if r["order_id"] == order_id)
-    qty = min(qty, o["qty"])
-    return qty * p["unit_price_usd"]
-def customer_tier(order_id: int) -> str:
-    o = ORDERS[order_id]
-    return CUSTOMERS[o["customer_id"]]["tier"]
-def apply_discount(amount_usd: int, tier: str) -> int:
-    return amount_usd * (100 - DISCOUNT_PCT[tier]) // 100
-def net_revenue_usd(order_id: int) -> int:
-    gross = apply_discount(order_gross_usd(order_id), customer_tier(order_id))
-    return max(0, gross - refund_usd(order_id))
-def to_local(amount_usd: int, currency: str) -> int:
-    return amount_usd * 10000 // FX_TO_USD_BP[currency]
-def inventory_position(product_id: int, region: str) -> int:
-    row = next(x for x in DATA["inventory"]
-               if x["product_id"] == product_id and x["region"] == region)
-    return row["on_hand"] - row["reserved"] + row["inbound"]
-def product_lead_time(product_id: int) -> int:
-    return PRODUCTS[product_id]["lead_time_days"]
-def product_id_for_top_seller(region: str, category: str, month_start: int, month_end: int) -> int:
-    totals = {}
-    for oid in get_orders(region, category, month_start, month_end):
-        o = ORDERS[oid]
-        totals[o["product_id"]] = totals.get(o["product_id"], 0) + o["qty"]
-    if not totals:
-        return -1
-    return min((-qty, pid) for pid, qty in totals.items())[1]
-def units_sold(product_id: int, region: str, month_start: int, month_end: int) -> int:
-    total = 0
-    for o in DATA["orders"]:
-        if o["product_id"] != product_id or o["status"] not in ("paid", "refunded"):
-            continue
-        c = CUSTOMERS[o["customer_id"]]
-        if c["region"] == region and month_start <= o["month"] <= month_end:
-            total += o["qty"]
-    return total
-def tickets_for_orders(order_ids: list, severity: str) -> list:
-    s = set(order_ids)
-    return sorted(t["ticket_id"] for t in DATA["tickets"]
-                  if t["order_id"] in s and t["severity"] == severity)
-def ticket_order_id(ticket_id: int) -> int:
-    return next(t["order_id"] for t in DATA["tickets"] if t["ticket_id"] == ticket_id)
-def sla_breached(ticket_id: int, first_response_limit_hours: int,
-                 resolution_limit_hours: int) -> bool:
-    t = next(x for x in DATA["tickets"] if x["ticket_id"] == ticket_id)
-    return (t["first_response_hours"] > first_response_limit_hours or
-            t["resolution_hours"] > resolution_limit_hours)
-def delayed_orders(order_ids: list) -> list:
-    s = set(order_ids)
-    return sorted(o["order_id"] for o in DATA["orders"]
-                  if o["order_id"] in s and o["ship_days"] > o["promised_days"])
-def unique_customers(order_ids: list) -> list:
-    return sorted({ORDERS[oid]["customer_id"] for oid in order_ids})
-def count_items(values: list) -> int:
-    return len(values)
-def sum_values(values: list) -> int:
-    return sum(values)
-def count_true(values: list) -> int:
-    return sum(1 for v in values if bool(v))
-def count_below(values: list, threshold: int) -> int:
-    return sum(1 for v in values if v < threshold)
-TOOLS = {
-    "region_currency": ("region_currency(region: str) -> str",
-                        "ISO currency code for a region.", region_currency),
-    "get_orders": ("get_orders(region: str, category: str, month_start: int, month_end: int) -> list[int]",
-                   "Paid/refunded order ids for a region, product category, and inclusive month window.",
-                   get_orders),
-    "order_gross_usd": ("order_gross_usd(order_id: int) -> int",
-                        "Gross order revenue in USD before discounts/refunds.", order_gross_usd),
-    "order_margin_usd": ("order_margin_usd(order_id: int) -> int",
-                         "Gross order margin in USD before discounts/refunds.", order_margin_usd),
-    "refund_usd": ("refund_usd(order_id: int) -> int",
-                   "Refund amount in USD for returned quantity on an order.", refund_usd),
-    "customer_tier": ("customer_tier(order_id: int) -> str",
-                      "Customer loyalty tier for an order.", customer_tier),
-    "apply_discount": ("apply_discount(amount_usd: int, tier: str) -> int",
-                       "Apply the order customer's loyalty discount to a USD amount.", apply_discount),
-    "net_revenue_usd": ("net_revenue_usd(order_id: int) -> int",
-                        "Net USD revenue after loyalty discount and refunds.", net_revenue_usd),
-    "to_local": ("to_local(amount_usd: int, currency: str) -> int",
-                 "Convert a USD integer amount to a local-currency integer.", to_local),
-    "inventory_position": ("inventory_position(product_id: int, region: str) -> int",
-                           "Available inventory position: on_hand - reserved + inbound.",
-                           inventory_position),
-    "product_lead_time": ("product_lead_time(product_id: int) -> int",
-                          "Supplier lead time in days for a product.", product_lead_time),
-    "product_id_for_top_seller": (
-        "product_id_for_top_seller(region: str, category: str, month_start: int, month_end: int) -> int",
-        "Product id with the highest units sold in a region/category/month window.",
-        product_id_for_top_seller),
-    "units_sold": ("units_sold(product_id: int, region: str, month_start: int, month_end: int) -> int",
-                   "Units sold for one product in a region and month window.", units_sold),
-    "tickets_for_orders": ("tickets_for_orders(order_ids: list[int], severity: str) -> list[int]",
-                           "Support ticket ids for given orders and severity.", tickets_for_orders),
-    "ticket_order_id": ("ticket_order_id(ticket_id: int) -> int",
-                        "Order id associated with a support ticket.", ticket_order_id),
-    "sla_breached": (
-        "sla_breached(ticket_id: int, first_response_limit_hours: int, resolution_limit_hours: int) -> bool",
-        "Whether a support ticket breaches first-response or resolution SLA.",
-        sla_breached),
-    "delayed_orders": ("delayed_orders(order_ids: list[int]) -> list[int]",
-                       "Subset of order ids whose ship_days exceeded promised_days.", delayed_orders),
-    "unique_customers": ("unique_customers(order_ids: list[int]) -> list[int]",
-                         "Unique customer ids among the given orders.", unique_customers),
-    "count_items": ("count_items(values: list) -> int", "Length of a list.", count_items),
-    "sum_values": ("sum_values(values: list[int]) -> int", "Sum a list of integers.", sum_values),
-    "count_true": ("count_true(values: list[bool]) -> int", "Count true values.", count_true),
-    "count_below": ("count_below(values: list[int], threshold: int) -> int",
-                    "Count values below a threshold.", count_below),
-}
-__all__ = [name for name in TOOLS.keys()] + ['TOOLS']