| |
| from __future__ import annotations |
|
|
| import hashlib |
| import json |
| import os |
| import random |
| import re |
| import time |
| import urllib.error |
| import urllib.parse |
| import urllib.request |
| from dataclasses import dataclass |
| from typing import Any |
|
|
|
|
| RETRY_CODES = {429, 500, 502, 503, 504} |
|
|
|
|
| def canonical_json(value: Any) -> str: |
| return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":")) |
|
|
|
|
| def sha256_json(value: Any) -> str: |
| return hashlib.sha256(canonical_json(value).encode()).hexdigest() |
|
|
|
|
| def extract_json(text: str) -> Any: |
| text = text.strip() |
| if text.startswith("```"): |
| text = re.sub(r"^```(?:json)?\s*", "", text) |
| text = re.sub(r"\s*```$", "", text) |
| try: |
| return json.loads(text) |
| except json.JSONDecodeError: |
| starts = [i for i in (text.find("["), text.find("{")) if i >= 0] |
| if not starts: |
| raise |
| start = min(starts) |
| for end in range(len(text), start, -1): |
| try: |
| return json.loads(text[start:end]) |
| except json.JSONDecodeError: |
| continue |
| raise |
|
|
|
|
| @dataclass |
| class ReviewResponse: |
| raw_body: dict |
| text: str |
| parsed: Any |
| usage: dict |
| model_version: str |
| latency_seconds: float |
| request_hash: str |
| response_hash: str |
| status_code: int |
|
|
|
|
| class ReviewClient: |
| def __init__( |
| self, |
| api_type: str, |
| base_url: str, |
| api_key: str, |
| model: str, |
| timeout: int = 180, |
| retries: int = 5, |
| extra_body: dict | None = None, |
| ): |
| self.api_type = api_type |
| self.base_url = base_url.rstrip("/") |
| self.api_key = api_key |
| self.model = model |
| self.timeout = timeout |
| self.retries = retries |
| self.extra_body = extra_body or {} |
| if api_type not in { |
| "openai_compatible", "anthropic_compatible", "generic_http_json", |
| "local_openai_compatible", "custom_adapter", |
| }: |
| raise ValueError(f"unsupported REVIEW_API_TYPE: {api_type}") |
|
|
| def _request_spec(self, system: str, user: str, max_tokens: int) -> tuple[str, dict, dict]: |
| if self.api_type == "anthropic_compatible": |
| url = self.base_url + "/messages" |
| body = { |
| "model": self.model, |
| "max_tokens": max_tokens, |
| "system": system, |
| "messages": [{"role": "user", "content": user}], |
| } |
| body.update(self.extra_body) |
| headers = { |
| "content-type": "application/json", |
| "x-api-key": self.api_key, |
| "anthropic-version": "2023-06-01", |
| } |
| return url, body, headers |
| if self.api_type in {"openai_compatible", "local_openai_compatible"}: |
| url = self.base_url + "/chat/completions" |
| body = { |
| "model": self.model, |
| "temperature": 0, |
| "max_tokens": max_tokens, |
| "messages": [{"role": "system", "content": system}, {"role": "user", "content": user}], |
| } |
| body.update(self.extra_body) |
| return url, body, {"content-type": "application/json", "authorization": f"Bearer {self.api_key}"} |
| url = self.base_url |
| body = {"model": self.model, "system": system, "input": user, "max_tokens": max_tokens} |
| body.update(self.extra_body) |
| return url, body, {"content-type": "application/json", "authorization": f"Bearer {self.api_key}"} |
|
|
| def _parse_text(self, payload: dict) -> tuple[str, dict, str]: |
| if self.api_type == "anthropic_compatible": |
| text = "\n".join( |
| block.get("text", "") for block in payload.get("content", []) |
| if isinstance(block, dict) and block.get("type") == "text" |
| ) |
| usage = payload.get("usage", {}) |
| model_version = str(payload.get("model", self.model)) |
| return text, usage, model_version |
| if self.api_type in {"openai_compatible", "local_openai_compatible"}: |
| text = payload["choices"][0]["message"]["content"] |
| return text, payload.get("usage", {}), str(payload.get("model", self.model)) |
| text = payload.get("output") or payload.get("text") or payload.get("response") or "" |
| return str(text), payload.get("usage", {}), str(payload.get("model", self.model)) |
|
|
| def complete_json(self, system: str, user: str, max_tokens: int = 4096) -> ReviewResponse: |
| url, body, headers = self._request_spec(system, user, max_tokens) |
| public_request = {"url_host": urllib.parse.urlparse(url).netloc, "body": body} |
| request_hash = sha256_json(public_request) |
| encoded = canonical_json(body).encode() |
| last_error: Exception | None = None |
| for attempt in range(self.retries + 1): |
| started = time.monotonic() |
| try: |
| request = urllib.request.Request(url, data=encoded, headers=headers, method="POST") |
| with urllib.request.urlopen(request, timeout=self.timeout) as response: |
| raw = response.read().decode("utf-8", errors="replace") |
| payload = json.loads(raw) |
| text, usage, model_version = self._parse_text(payload) |
| parsed = extract_json(text) |
| return ReviewResponse( |
| raw_body=payload, text=text, parsed=parsed, usage=usage, |
| model_version=model_version, latency_seconds=time.monotonic() - started, |
| request_hash=request_hash, response_hash=hashlib.sha256(raw.encode()).hexdigest(), |
| status_code=response.status, |
| ) |
| except urllib.error.HTTPError as exc: |
| last_error = exc |
| if exc.code not in RETRY_CODES or attempt >= self.retries: |
| raise |
| except (urllib.error.URLError, TimeoutError, json.JSONDecodeError) as exc: |
| last_error = exc |
| if attempt >= self.retries: |
| raise |
| delay = min(60.0, (2 ** attempt) + random.random()) |
| time.sleep(delay) |
| raise RuntimeError(f"request failed: {type(last_error).__name__}") |
|
|
|
|
| def client_from_env(api_key: str) -> ReviewClient: |
| extra = {} |
| if os.environ.get("REVIEW_EXTRA_BODY_JSON"): |
| extra = json.loads(os.environ["REVIEW_EXTRA_BODY_JSON"]) |
| return ReviewClient( |
| api_type=os.environ.get("REVIEW_API_TYPE", "anthropic_compatible"), |
| base_url=os.environ["REVIEW_API_BASE_URL"], |
| api_key=api_key, |
| model=os.environ["REVIEW_MODEL_PRIMARY"], |
| timeout=int(os.environ.get("REVIEW_TIMEOUT_SECONDS", "180")), |
| retries=int(os.environ.get("REVIEW_MAX_RETRIES", "5")), |
| extra_body=extra, |
| ) |
|
|
