Score many texts

from decimal import Decimal
from sqwishai import OneHot

decisions = [{"id": "spam", "kind": "binary", "question": "Is the comment spam?"}]

with OneHot() as client:
    quote = client.estimate(context="Where can I buy this jacket?", decisions=decisions)

print(quote["input_tokens"], quote["maximum_charge_usd"])
print("100,000 comments:", Decimal(quote["maximum_charge_usd"]) * 100_000)

import { OneHot, type Decision } from "sqwishai";

const decisions: Decision[] = [{ id: "spam", kind: "binary", question: "Is the comment spam?" }];
const client = new OneHot();
const quote = await client.estimate({ context: "Where can I buy this jacket?", decisions });

console.log(quote.input_tokens, quote.maximum_charge_usd);

import asyncio
import time
from sqwishai import AsyncOneHot

RPM = 30           # your tier's requests a minute: 30 at tier 0
CONCURRENCY = 1    # your tier's operations at once: 1 at tier 0

async def score_all(items, decisions):
    results = [None] * len(items)
    todo = iter(range(len(items)))
    async with AsyncOneHot() as client:
        async def worker():
            for i in todo:
                started = time.monotonic()
                try:
                    results[i] = await client.decide(
                        context=items[i]["text"], decisions=decisions,
                        idempotency_key=f"comment-{items[i]['id']}-v1")
                except Exception as error:  # keep it, and send it again later
                    results[i] = error
                await asyncio.sleep(max(0, 60 * CONCURRENCY / RPM - (time.monotonic() - started)))
        await asyncio.gather(*(worker() for _ in range(CONCURRENCY)))
    return results

import { OneHot, type Decision } from "sqwishai";

const RPM = 30;         // your tier's requests a minute: 30 at tier 0
const CONCURRENCY = 1;  // your tier's operations at once: 1 at tier 0
const client = new OneHot();
const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));

async function scoreAll(items: { id: string; text: string }[], decisions: Decision[]) {
  const results: unknown[] = new Array(items.length);
  let next = 0;
  async function worker() {
    for (let i = next++; i < items.length; i = next++) {
      const started = Date.now();
      results[i] = await client
        .decide({ context: items[i].text, decisions },
                { idempotencyKey: `comment-${items[i].id}-v1` })
        .catch((error) => error); // keep it, and send it again later
      await sleep(Math.max(0, (60_000 * CONCURRENCY) / RPM - (Date.now() - started)));
    }
  }
  await Promise.all(Array.from({ length: CONCURRENCY }, worker));
  return results;
}