"""Readable oracle, not code injected into candidate projects.""" from __future__ import annotations import copy import json import os from pathlib import Path from klein_code_bench.catalog import FAMILIES from klein_code_bench.protocol import TIERS from klein_code_bench.reference.domains import solve class Fault(Exception): pass def integer(value, minimum=0, maximum=None): return ( type(value) is int and value >= minimum and (maximum is None or value <= maximum) ) def req_op(request): return request.get("op") if isinstance(request, dict) else None class Service: def __init__(self, family, tier, state_dir=None): self.family = FAMILIES[family] self.level = list(TIERS).index(tier) self.directory = Path(state_dir) if state_dir is not None else None self.state = {"revision": 0, "docs": {}, "history": [], "tokens": {}} self.stack = [] if self.directory is not None: self.directory.mkdir(parents=True, exist_ok=True) path = self.directory / "workspace.json" if path.exists(): self.state = json.loads(path.read_text(encoding="utf-8")) def persist(self): if self.directory is None or self.stack: return path = self.directory / "workspace.json" temporary = self.directory / "workspace.tmp" with temporary.open("w", encoding="utf-8") as f: json.dump(self.state, f, ensure_ascii=True, allow_nan=False) f.flush() os.fsync(f.fileno()) os.replace(temporary, path) if os.name == "posix": fd = os.open(self.directory, os.O_RDONLY) try: os.fsync(fd) finally: os.close(fd) def compute(self, value): if not isinstance(value, dict) or not all( k in value for k in self.family.required ): raise Fault("invalid_input") return solve(self.family.slug, copy.deepcopy(value)) def request(self, request): before, stack = copy.deepcopy(self.state), copy.deepcopy(self.stack) try: result = self.dispatch(request) response = {"ok": True, "result": result} # Writes inside a transaction remain volatile until outermost commit. if ( self.level == 3 and not self.stack and ( self.state != before or bool(stack) and req_op(request) == "commit" ) ): self.persist() return copy.deepcopy(response) except Fault as error: self.state, self.stack = before, stack return {"ok": False, "error": str(error)} def dispatch(self, req, inside_batch=False): if not isinstance(req, dict) or not isinstance(req.get("op"), str): raise Fault("invalid_request") op = req["op"] allowed = {"solve"} if self.level >= 1: allowed |= {"put", "get", "delete", "list", "evaluate", "status"} if self.level >= 2: allowed |= {"batch", "begin", "commit", "rollback"} if self.level == 3: allowed |= {"history", "scan"} if op not in allowed: raise Fault("invalid_request") if inside_batch and op not in { "solve", "put", "get", "delete", "list", "evaluate", "status", }: raise Fault("invalid_request") token = req.get("token") if self.level == 3 and "token" in req: if ( inside_batch or op not in {"put", "delete", "batch"} or not isinstance(token, str) or not token ): raise Fault("invalid_request") canonical = json.dumps( {k: v for k, v in req.items() if k != "token"}, sort_keys=True, separators=(",", ":"), ) cached = self.state["tokens"].get(token) if cached: if cached["request"] != canonical: raise Fault("idempotency_conflict") return copy.deepcopy(cached["result"]) else: token = None result = self.execute(op, req) if token is not None: self.state["tokens"][token] = { "request": canonical, "result": copy.deepcopy(result), } return result def execute(self, op, req): if op == "solve": return self.compute(req.get("input")) docs = self.state["docs"] if op in {"put", "get", "delete", "evaluate"}: key = req.get("key") if ( not isinstance(key, str) or not key or op == "put" and "value" not in req ): raise Fault("invalid_request") if self.level >= 2 and op in {"put", "delete"} and "if_revision" in req: if not integer(req["if_revision"]): raise Fault("invalid_request") if req["if_revision"] != self.state["revision"]: raise Fault("conflict") if op != "put" and key not in docs: raise Fault("not_found") if op == "get": return copy.deepcopy(docs[key]) if op == "evaluate": return self.compute(docs[key]["value"]) self.state["revision"] += 1 revision = self.state["revision"] if op == "put": docs[key] = { "key": key, "value": copy.deepcopy(req["value"]), "revision": revision, } else: del docs[key] if self.level == 3: event = {"revision": revision, "op": op, "key": key} if op == "put": event["value"] = copy.deepcopy(req["value"]) self.state["history"].append(event) return {"key": key, "revision": revision} if op == "list": prefix = req.get("prefix", "") if not isinstance(prefix, str): raise Fault("invalid_request") return sorted(k for k in docs if k.startswith(prefix)) if op == "status": return {"revision": self.state["revision"], "size": len(docs)} if op == "batch": commands = req.get("commands") if not isinstance(commands, list) or len(commands) > 32: raise Fault("invalid_request") return [self.dispatch(command, inside_batch=True) for command in commands] if op == "begin": if len(self.stack) >= 8: raise Fault("transaction_limit") self.stack.append(copy.deepcopy(self.state)) return {"depth": len(self.stack)} if op in {"commit", "rollback"}: if not self.stack: raise Fault("no_transaction") previous = self.stack.pop() if op == "rollback": self.state = previous return {"depth": len(self.stack)} if op == "history": after, limit = req.get("after", 0), req.get("limit", 100) if not integer(after) or not integer(limit, maximum=100): raise Fault("invalid_request") return copy.deepcopy( [e for e in self.state["history"] if e["revision"] > after][:limit] ) if op == "scan": prefix, after, limit = ( req.get("prefix", ""), req.get("after", ""), req.get("limit", 100), ) if ( not isinstance(prefix, str) or not isinstance(after, str) or not integer(limit, maximum=100) ): raise Fault("invalid_request") keys = sorted(k for k in docs if k.startswith(prefix) and k > after) chosen = keys[:limit] return { "items": [copy.deepcopy(docs[k]) for k in chosen], "next": chosen[-1] if chosen and len(keys) > len(chosen) else None, } raise Fault("invalid_request")