Reorganize: scripts/eval/provider.py

scripts/eval/provider.py

@@ -0,0 +1,252 @@
+"""Provider abstraction for eval scripts.
+
+Defaults to HuggingFace Inference API using the HF_TOKEN from .env.
+Override via environment variables if needed:
+
+  PROVIDER=anthropic   → direct Anthropic SDK
+  PROVIDER=openrouter  → OpenRouter (Claude, GPT-4V, Gemini, ...)
+  PROVIDER=hf          → HuggingFace Inference API (default)
+
+  EVAL_MODEL=<model_id>   → override the default model for any provider
+"""
+
+import base64
+import io
+import os
+from pathlib import Path
+
+from PIL import Image
+
+# Load .env from repo root so HF_TOKEN etc. are available without manual export.
+_env_path = Path(__file__).resolve().parents[2] / ".env"
+if _env_path.exists():
+    from dotenv import load_dotenv
+    load_dotenv(_env_path, override=False)  # don't clobber already-set vars
+
+# ── defaults ──────────────────────────────────────────────────────────────────
+
+# HF model options by backend:
+#   hf-inference (free tier):  meta-llama/Llama-3.2-11B-Vision-Instruct
+#   novita / together backends: Qwen/Qwen2-VL-7B-Instruct (set HF_BACKEND=novita)
+#
+# To use a different model:  export EVAL_MODEL=<model_id>
+# To use a different backend: export HF_BACKEND=novita  (or together, fireworks-ai)
+HF_BACKEND = os.environ.get("HF_BACKEND", "together")
+HF_MODEL   = "google/gemma-4-31B-it"
+
+DEFAULTS = {
+    "anthropic":  "claude-opus-4-5",
+    "openrouter": "anthropic/claude-opus-4-5",
+    "hf":         HF_MODEL,
+}
+
+# Auto-detect provider: prefer whatever key is present.
+def _default_provider() -> str:
+    if os.environ.get("ANTHROPIC_API_KEY"):
+        return "anthropic"
+    if os.environ.get("OPENROUTER_API_KEY"):
+        return "openrouter"
+    return "hf"  # HF_TOKEN loaded from .env
+
+
+def get_provider() -> str:
+    return os.environ.get("PROVIDER", _default_provider()).lower()
+
+
+def get_model() -> str:
+    return os.environ.get("EVAL_MODEL", DEFAULTS[get_provider()])
+
+
+def get_client():
+    """Return a client for the configured provider."""
+    provider = get_provider()
+    print(f"[provider] {provider} / {get_model()}")
+
+    if provider == "anthropic":
+        import anthropic
+        return _AnthropicWrapper(
+            anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
+        )
+
+    from openai import OpenAI
+
+    if provider == "openrouter":
+        return OpenAI(
+            base_url="https://openrouter.ai/api/v1",
+            api_key=os.environ["OPENROUTER_API_KEY"],
+            default_headers={
+                "HTTP-Referer": "https://github.com/midah/patent-wireframes",
+                "X-Title": "patent-wireframes-eval",
+            },
+        )
+
+    if provider == "hf":
+        token = os.environ.get("HF_TOKEN")
+        if not token:
+            raise RuntimeError("HF_TOKEN not set. Add it to .env or export it.")
+        backend = os.environ.get("HF_BACKEND", HF_BACKEND)
+        return OpenAI(
+            base_url=f"https://router.huggingface.co/{backend}/v1",
+            api_key=token,
+        )
+
+    raise ValueError(f"Unknown PROVIDER={provider!r}. Choose: anthropic, openrouter, hf")
+
+
+# ── image encoding ────────────────────────────────────────────────────────────
+
+def encode_image(path: Path, max_long_edge: int = 1024) -> tuple[str, str]:
+    """Return (base64_str, media_type) for an image file, resized to fit."""
+    img = Image.open(path).convert("RGB")
+    w, h = img.size
+    scale = min(max_long_edge / max(w, h), 1.0)
+    if scale < 1.0:
+        img = img.resize((int(w * scale), int(h * scale)), Image.LANCZOS)
+    buf = io.BytesIO()
+    img.save(buf, format="JPEG", quality=85)
+    return base64.standard_b64encode(buf.getvalue()).decode(), "image/jpeg"
+
+
+# ── unified message API ───────────────────────────────────────────────────────
+
+_NOTHINK_PREFIX = "/nothink\n"
+
+def _inject_nothink(messages: list[dict]) -> list[dict]:
+    """Prepend /nothink to any text block so thinking models skip CoT."""
+    if get_provider() != "hf" or "gemma" not in get_model().lower():
+        return messages
+    import copy
+    msgs = copy.deepcopy(messages)
+    content = msgs[0].get("content", "")
+
+    # Plain string content — prepend directly
+    if isinstance(content, str):
+        if not content.startswith("/nothink"):
+            msgs[0]["content"] = _NOTHINK_PREFIX + content
+        return msgs
+
+    # List of blocks — find first text block
+    for block in content:
+        if isinstance(block, dict) and block.get("type") == "text" and block.get("text", "").strip():
+            if not block["text"].startswith("/nothink"):
+                block["text"] = _NOTHINK_PREFIX + block["text"]
+            return msgs
+
+    # No text block found — append one
+    content.append({"type": "text", "text": _NOTHINK_PREFIX})
+    return msgs
+
+
+def chat(client, messages: list[dict], max_tokens: int = 200) -> str:
+    """Send messages and return the text response.
+
+    Works with both the Anthropic wrapper and OpenAI-compatible clients.
+    """
+    if isinstance(client, _AnthropicWrapper):
+        return client.chat(messages, max_tokens)
+
+    # OpenAI-compatible (OpenRouter, HF) with exponential backoff on rate limits
+    import time
+    messages = _inject_nothink(messages)
+    for attempt in range(4):
+        try:
+            resp = client.chat.completions.create(
+                model=get_model(),
+                messages=messages,
+                max_tokens=max(max_tokens, 600),
+            )
+            return (resp.choices[0].message.content or "").strip()
+        except Exception as e:
+            if "429" in str(e) or "rate" in str(e).lower():
+                wait = 4 ** attempt  # 1, 4, 16, 64 seconds
+                print(f"  Rate limit, retrying in {wait}s...")
+                time.sleep(wait)
+            else:
+                raise
+    return ""
+
+
+def image_message(b64: str, media_type: str, text: str) -> list[dict]:
+    """Build a user message with one image + text, in OpenAI vision format."""
+    return [{
+        "role": "user",
+        "content": [
+            {"type": "image_url",
+             "image_url": {"url": f"data:{media_type};base64,{b64}"}},
+            {"type": "text", "text": text},
+        ],
+    }]
+
+
+def multi_image_message(
+    images: list[tuple[str, str]],   # list of (b64, media_type)
+    text_before: str = "",
+    text_after: str = "",
+    labels: list[str] | None = None,
+) -> list[dict]:
+    """Build a user message with multiple images, interleaved with labels."""
+    content = []
+    if text_before:
+        content.append({"type": "text", "text": text_before})
+    for i, (b64, media_type) in enumerate(images):
+        if labels:
+            content.append({"type": "text", "text": labels[i]})
+        content.append({"type": "image_url",
+                         "image_url": {"url": f"data:{media_type};base64,{b64}"}})
+    if text_after:
+        content.append({"type": "text", "text": text_after})
+    return [{"role": "user", "content": content}]
+
+
+# ── Anthropic SDK wrapper (translates to OpenAI message format) ───────────────
+
+class _AnthropicWrapper:
+    """Wraps anthropic.Anthropic to accept OpenAI-format image_url content."""
+
+    def __init__(self, client):
+        self._client = client
+
+    def chat(self, messages: list[dict], max_tokens: int) -> str:
+        converted = self._convert_messages(messages)
+        resp = self._client.messages.create(
+            model=get_model(),
+            max_tokens=max_tokens,
+            messages=converted,
+        )
+        return resp.content[0].text.strip()
+
+    @staticmethod
+    def _convert_messages(messages: list[dict]) -> list[dict]:
+        """Convert OpenAI image_url format → Anthropic base64 format."""
+        out = []
+        for msg in messages:
+            role = msg["role"]
+            content = msg["content"]
+            if isinstance(content, str):
+                out.append({"role": role, "content": content})
+                continue
+            new_content = []
+            for block in content:
+                if block["type"] == "image_url":
+                    url = block["image_url"]["url"]
+                    # data:image/jpeg;base64,<data>
+                    if url.startswith("data:"):
+                        meta, data = url.split(",", 1)
+                        media_type = meta.split(":")[1].split(";")[0]
+                        new_content.append({
+                            "type": "image",
+                            "source": {
+                                "type": "base64",
+                                "media_type": media_type,
+                                "data": data,
+                            },
+                        })
+                    else:
+                        new_content.append({
+                            "type": "image",
+                            "source": {"type": "url", "url": url},
+                        })
+                else:
+                    new_content.append(block)
+            out.append({"role": role, "content": new_content})
+        return out