| """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} |
| |
| 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") |
|
|
