"""Async DeepSeek client for the pipeline: JSON mode, many parallel requests, response cache, cost ledger, budget. - model `deepseek-flash` (DeepSeek-V4.1-Flash); thinking disabled unless asked (`thinking=True, effort='low'`) - the key is read from $DEEPSEEK_API_KEY or /root/.config/deepseek/api_key and never printed - every successful response is cached in runs/cache.sqlite (key = hash of the request) -> reruns cost nothing - every paid call is appended to runs/ledger.jsonl with its token usage and price - budget: stops scheduling new calls when ledger total + in-flight reservations would exceed `budget_usd`, or when the live account balance (GET /user/balance, checked every 60 s) drops below `min_balance` """ import asyncio import hashlib import json import os import random import sqlite3 import time from datetime import datetime, timezone from pathlib import Path import httpx from openai import APIConnectionError, APIStatusError, APITimeoutError, AsyncOpenAI from common import RUNS # USD per 1M tokens: (input cache hit, input cache miss, output); api-docs.deepseek.com/quick_start/pricing, 26.09.2026 PRICES = {"deepseek-flash": {"peak": (0.006, 0.30, 1.20), "offpeak": (0.003, 0.15, 0.60)}, "deepseek-v4-pro": {"peak": (0.044, 1.32, 3.96), "offpeak": (0.022, 0.66, 1.98)}} def is_peak(ts=None): d = datetime.fromtimestamp(ts or time.time(), timezone.utc) return d.weekday() < 5 and (1 <= d.hour < 4 or 6 <= d.hour < 10) def price(model, usage, ts=None): hit_p, miss_p, out_p = PRICES[model]["peak" if is_peak(ts) else "offpeak"] hit = usage.get("prompt_cache_hit_tokens") or 0 miss = usage.get("prompt_cache_miss_tokens") if miss is None: miss = (usage.get("prompt_tokens") or 0) - hit return (hit * hit_p + miss * miss_p + (usage.get("completion_tokens") or 0) * out_p) / 1e6 class BudgetExceeded(Exception): pass class DS: def __init__(self, model="deepseek-flash", concurrency=256, budget_usd=None, min_balance=0.3, tag="", cache_path=None, ledger_path=None, timeout=900): key = os.environ.get("DEEPSEEK_API_KEY") or Path("/root/.config/deepseek/api_key").read_text().strip() self._key = key limits = httpx.Limits(max_connections=concurrency + 16, max_keepalive_connections=concurrency + 16) self.http = httpx.AsyncClient(limits=limits, timeout=httpx.Timeout(timeout, connect=30)) self.client = AsyncOpenAI(api_key=key, base_url="https://api.deepseek.com", max_retries=0, http_client=self.http) self.model, self.tag = model, tag self.sem = asyncio.Semaphore(concurrency) self.budget, self.min_balance = budget_usd, min_balance RUNS.mkdir(parents=True, exist_ok=True) self.cache = sqlite3.connect(cache_path or RUNS / "cache.sqlite", timeout=60, check_same_thread=False) self.cache.execute("PRAGMA journal_mode=WAL") self.cache.execute("CREATE TABLE IF NOT EXISTS cache(k TEXT PRIMARY KEY, content TEXT, usage TEXT, ts REAL)") self.ledger_path = Path(ledger_path or RUNS / "ledger.jsonl") self.inflight = 0.0 self.spent_run = 0.0 self.stats = {"calls": 0, "cached": 0, "retries": 0, "failed": 0, "repairs": 0, "invalid": 0} self._ledger_total, self._ledger_ts = self._read_ledger(), time.time() self._balance, self._balance_ts = None, 0.0 self._bal_lock = asyncio.Lock() self.stopped = False # ------------------------------------------------------------ accounting def _read_ledger(self): if not self.ledger_path.exists(): return 0.0 tot = 0.0 with open(self.ledger_path, encoding="utf-8") as f: for line in f: try: tot += json.loads(line)["cost"] except Exception: pass return tot def spent_total(self): if time.time() - self._ledger_ts > 20: # other processes may be spending too self._ledger_total, self._ledger_ts = self._read_ledger(), time.time() self.spent_run = 0.0 return self._ledger_total + self.spent_run async def balance(self, force=False): """Live account balance, refreshed at most once a minute by a single coroutine (no thundering herd).""" if not force and time.time() - self._balance_ts < 60: return self._balance if self._bal_lock.locked(): return self._balance async with self._bal_lock: if not force and time.time() - self._balance_ts < 60: return self._balance try: r = await self.http.get("https://api.deepseek.com/user/balance", timeout=15, headers={"Authorization": f"Bearer {self._key}"}) self._balance = float(r.json()["balance_infos"][0]["total_balance"]) except Exception: pass finally: self._balance_ts = time.time() return self._balance async def _check_budget(self, reserve): if self.stopped: raise BudgetExceeded("stopped") if self.budget is not None and self.spent_total() + self.inflight + reserve > self.budget: self.stopped = True raise BudgetExceeded(f"budget {self.budget} USD reached (spent {self.spent_total():.3f})") bal = await self.balance() if bal is not None and bal - self.inflight < self.min_balance: self.stopped = True raise BudgetExceeded(f"account balance {bal:.2f} USD below floor {self.min_balance}") def _account(self, usage, tag): ts = time.time() cost = price(self.model, usage, ts) self.spent_run += cost rec = {"ts": round(ts, 1), "tag": tag or self.tag, "model": self.model, "peak": is_peak(ts), "hit": usage.get("prompt_cache_hit_tokens") or 0, "miss": usage.get("prompt_cache_miss_tokens") or 0, "out": usage.get("completion_tokens") or 0, "reasoning": ((usage.get("completion_tokens_details") or {}).get("reasoning_tokens") or 0), "cost": round(cost, 7)} with open(self.ledger_path, "a", encoding="utf-8") as f: f.write(json.dumps(rec) + "\n") # ------------------------------------------------------------ cache def _key_of(self, payload): return hashlib.sha256(json.dumps(payload, ensure_ascii=False, sort_keys=True).encode()).hexdigest() def _cache_get(self, k): r = self.cache.execute("SELECT content, usage FROM cache WHERE k=?", (k,)).fetchone() return (r[0], json.loads(r[1])) if r else None def _cache_put(self, k, content, usage): for _ in range(5): try: self.cache.execute("INSERT OR REPLACE INTO cache VALUES (?,?,?,?)", (k, content, json.dumps(usage), time.time())) self.cache.commit() return except sqlite3.OperationalError: time.sleep(0.5) # ------------------------------------------------------------ calls async def raw(self, messages, *, max_tokens, temperature=0.7, thinking=False, effort="low", json_mode=True, tag=""): """One chat completion -> (content, usage) or (None, reason). Cached, retried, budgeted.""" payload = {"model": self.model, "messages": messages, "max_tokens": max_tokens, "json": json_mode, "temperature": None if thinking else temperature, "thinking": effort if thinking else False} k = self._key_of(payload) hit = self._cache_get(k) if hit: self.stats["cached"] += 1 return hit hit_p, miss_p, out_p = PRICES[self.model]["peak" if is_peak() else "offpeak"] est_in = sum(len(m["content"]) for m in messages) / 2.6 reserve = (est_in * miss_p + max_tokens * out_p * 0.6) / 1e6 await self._check_budget(reserve) async with self.sem: await self._check_budget(reserve) self.inflight += reserve try: kw = {"model": self.model, "messages": messages, "max_tokens": max_tokens} if json_mode: kw["response_format"] = {"type": "json_object"} if thinking: kw["reasoning_effort"] = effort kw["extra_body"] = {"thinking": {"type": "enabled"}} else: kw["temperature"] = temperature kw["extra_body"] = {"thinking": {"type": "disabled"}} last = "unknown" for attempt in range(8): try: r = await self.client.chat.completions.create(**kw) self.stats["calls"] += 1 usage = r.usage.model_dump() if r.usage else {} self._account(usage, tag) ch = r.choices[0] content = ch.message.content or "" if ch.finish_reason == "length": return None, "length" if not content.strip(): last = "empty" raise ValueError("empty content") self._cache_put(k, content, usage) return content, usage except APIStatusError as e: last = f"http {e.status_code}" if e.status_code not in (408, 409, 429) and e.status_code < 500: self.stats["failed"] += 1 return None, f"{last}: {str(e)[:200]}" except (APIConnectionError, APITimeoutError, ValueError, httpx.HTTPError) as e: last = type(e).__name__ self.stats["retries"] += 1 await asyncio.sleep(min(60, 2 ** attempt) + random.random() * 2) self.stats["failed"] += 1 return None, last finally: self.inflight -= reserve async def json(self, messages, *, max_tokens, temperature=0.7, thinking=False, effort="low", validate=None, repairs=2, tag="", return_last=False): """JSON call with validation; on a bad answer asks the model to fix it (up to `repairs` times). `validate(obj)` returns None when OK or an error message (Polish) shown to the model. Returns (obj, None) or (None, error); with return_last=True a still-invalid last object is returned together with its error (the caller may keep its valid parts).""" msgs = list(messages) err, last = None, None for attempt in range(repairs + 1): mt = max_tokens if attempt == 0 else int(max_tokens * 1.3) content, info = await self.raw(msgs, max_tokens=mt, temperature=temperature, thinking=thinking, effort=effort, tag=tag) if content is None: if info == "length" and attempt < repairs: max_tokens = int(max_tokens * 1.6) continue return None, f"api: {info}" try: obj = json.loads(content) err = validate(obj) if validate else None except json.JSONDecodeError as e: obj, err = None, f"niepoprawny JSON ({e})" except Exception as e: # validator crashed on an unexpected shape obj, err = None, f"zła struktura JSON ({type(e).__name__}: {e})" if not err: return obj, None if isinstance(obj, dict): last = obj self.stats["invalid"] += 1 try: with open(RUNS / "invalid.jsonl", "a", encoding="utf-8") as f: f.write(json.dumps({"ts": round(time.time()), "tag": tag, "attempt": attempt, "err": err[:400]}, ensure_ascii=False) + "\n") except OSError: pass if attempt < repairs: self.stats["repairs"] += 1 msgs = msgs + [{"role": "assistant", "content": content}, {"role": "user", "content": f"Odpowiedź wymaga poprawy: {err}\n" f"Zwróć CAŁY poprawiony obiekt json w tym samym formacie."}] return (last if return_last else None), f"invalid: {err}" def summary(self): return (f"calls={self.stats['calls']} cached={self.stats['cached']} retries={self.stats['retries']} " f"failed={self.stats['failed']} invalid={self.stats['invalid']} repairs={self.stats['repairs']} " f"spent_total={self.spent_total():.3f}$ inflight={self.inflight:.3f}$ balance={self._balance}") async def progress(self, label, done_fn, total, every=30): t0 = time.time() while not self.stopped: await asyncio.sleep(every) d = done_fn() rate = d / max(1e-6, time.time() - t0) * 60 print(f"[{time.strftime('%H:%M:%S')}] {label}: {d}/{total} ({rate:.0f}/min) {self.summary()}", flush=True) async def aclose(self): await self.http.aclose()