revert(handship-hf): restore MediaPipe client-side hand tracking

Remove LocateAnything-3B server stack, ZeroGPU deps, and calibration flow.
Back to browser MediaPipe Hand Landmarker + static HF Space (sdk: static).

DEVELOPERS.md

@@ -12,8 +12,6 @@ When creating the Space from this repository, set **App directory** to:
 handship-hf
 ```
 
-Use **ZeroGPU** hardware (`sdk: gradio`, `app_file: app.py`). LocateAnything runs via `@spaces.GPU` — not on CPU basic.
-
 ## Run locally
 
 ```bash
@@ -21,44 +19,15 @@ cd handship-hf
 chmod +x scripts/fetch-kenney-assets.sh
 ./scripts/fetch-kenney-assets.sh   # Kenney CC0 → assets/
 
-pip install torch torchvision
 pip install -r requirements.txt
-python app.py
-# or: uvicorn app:app --host 0.0.0.0 --port 7860
+uvicorn app:app --host 0.0.0.0 --port 7860
 ```
 
-Open `http://localhost:7860/game/` — at **Play**, your hand is calibrated once; webcam frames are sent to `POST /api/hand/track` where **LocateAnything-3B** tracks **your** hand via a visual prompt.
-
 ## Stack
 
 - **Three.js** — 3D TPS game in the browser
-- **nvidia/LocateAnything-3B** — vision-language grounding (GPU server)
-- **Gradio Server (`gradio.Server`) + ZeroGPU** — `@spaces.GPU` inference API
-
-## Hand calibration
-
-1. Click **Jouer** / **Rejouer**
-2. Show your hand clearly in front of the webcam
-3. The server runs `ground_single` with `LOCATE_HAND_PROMPT`, crops your hand, and stores it as a **visual prompt**
-4. Later frames use `detect_visual_prompt` to match only that hand category
-
-Tune prompts via Space secrets / env vars:
-
-```bash
-LOCATE_HAND_PROMPT="my right hand"
-LOCATE_FINGER_PROMPT="index fingertip of my right hand"
-LOCATE_HAND_SELECT=temporal   # temporal | center | largest
-```
-
-## API
-
-| Endpoint | Method | Description |
-|----------|--------|-------------|
-| `/api/hand/status` | GET | Model load state, calibration, prompts |
-| `/api/hand/calibrate` | POST | JPEG frame → store your hand visual prompt |
-| `/api/hand/calibrate` | DELETE | Clear stored visual prompt |
-| `/api/hand/track` | POST | JPEG frame → control packet |
-| `/api/hand/reset` | POST | Clear smoothing state |
+- **MediaPipe Tasks Vision (JS)** — client-side hand tracking
+- **Gradio** — Space shell
 
 ## Desktop UE build
 

README.md

@@ -3,14 +3,11 @@ title: HandShip 3D — Hand-controlled spaceship
 emoji: 🚀
 colorFrom: indigo
 colorTo: blue
-sdk: gradio
-app_file: app.py
-python_version: 3.11
-suggested_hardware: zero-a10g
-startup_duration_timeout: 1h
+sdk: static
+app_file: index.html
 pinned: false
 license: mit
-short_description: 3D spaceship game controlled by hand (ZeroGPU)
+short_description: Fly a 3D spaceship with your hand in the browser
 ---
 
 # HandShip 3D
@@ -18,40 +15,26 @@ short_description: 3D spaceship game controlled by hand (ZeroGPU)
 Playable **third-person spaceship** game in your browser:
 
 - **Three.js** — 3D flight, asteroids, score & lives
-- **nvidia/LocateAnything-3B** — hand tracking via **ZeroGPU** (Gradio SDK)
+- **MediaPipe** — hand tracking runs client-side (webcam)
 - **Web Audio** — procedural music & SFX
 
 Open the Space, click **Jouer**, allow the webcam, then steer with your fingers.
 
-## Hardware
-
-Set Space hardware to **ZeroGPU** (free, Gradio only). Inference runs on `@spaces.GPU` workers.
-
-Optional Space variable:
-
-```bash
-GRADIO_SSR_MODE=false
-```
-
 ## Controls
 
 | Hand gesture | Action |
 |--------------|--------|
-| Finger direction (palm → index) | Fly that way (left/right/up/down) |
+| Finger direction (wrist → fingertips) | Fly that way (left/right/up/down) |
 | Raised index finger | Boost speed |
 
-## Local dev
-
-```bash
-pip install torch torchvision
-pip install -r requirements.txt
-python app.py   # or: uvicorn app:app --host 0.0.0.0 --port 7860
-```
-
-On local machine `@spaces.GPU` is a no-op (runs on CPU/CUDA if available).
-
 ## Gameplay
 
 - Dodge **26 asteroids**, score +1 per asteroid passed
 - **3 lives**, local high-score record
 - Mute button (bottom-left)
+
+## Local dev (optional Gradio shell)
+
+```bash
+uvicorn app:app --host 0.0.0.0 --port 7860
+```

app.py

@@ -1,113 +1,46 @@
-"""HandShip HF Space — Gradio Server + ZeroGPU + browser game (LocateAnything-3B)."""
+"""HandShip HF Space — 3D TPS playable in browser (Three.js + MediaPipe)."""
 
 from __future__ import annotations
 
-import os
 from pathlib import Path
 
-import spaces
-from fastapi import File, HTTPException, UploadFile
-from fastapi.responses import RedirectResponse
+import gradio as gr
+from fastapi import FastAPI
 from fastapi.staticfiles import StaticFiles
-from gradio import Server
 
 WEB_DIR = Path(__file__).resolve().parent
 
-app = Server(title="HandShip 3D")
-app.mount("/game", StaticFiles(directory=str(WEB_DIR), html=True), name="game")
-
-
-def _tracker():
-    from services.locate import hand_tracker as ht
-
-    return ht
-
-
-@app.get("/")
-def root():
-    return RedirectResponse(url="/game/", status_code=302)
-
-
-@spaces.GPU(duration=180)
-def hand_calibrate_gpu(image_bytes: bytes) -> dict:
-    """LocateAnything calibration — runs on ZeroGPU when available."""
-    return _tracker().calibrate_from_frame(image_bytes)
-
-
-@spaces.GPU(duration=90)
-def hand_track_gpu(image_bytes: bytes) -> dict:
-    """LocateAnything per-frame tracking — runs on ZeroGPU when available."""
-    return _tracker().frame_to_control(image_bytes)
-
-
-@app.get("/api/hand/status")
-def hand_status():
-    status = _tracker().worker_status()
-    status["backend"] = "gradio-server-zerogpu"
-    status["zeroGpu"] = os.environ.get("SPACES_ZERO_GPU") == "1"
-    return status
-
-
-@app.post("/api/hand/reset")
-def hand_reset():
-    _tracker().reset_smoothing()
-    return {"ok": True}
-
-
-@app.post("/api/hand/calibrate")
-async def hand_calibrate(image: UploadFile = File(...)):
-    if not image.content_type or not image.content_type.startswith("image/"):
-        raise HTTPException(status_code=400, detail="Expected an image upload.")
-
-    payload = await image.read()
-    if not payload:
-        raise HTTPException(status_code=400, detail="Empty image upload.")
-
-    try:
-        result = hand_calibrate_gpu(payload)
-    except Exception as exc:  # noqa: BLE001
-        import traceback
-
-        traceback.print_exc()
-        detail = str(exc)
-        if detail in {"TypeError", "RuntimeError", "ValueError"}:
-            detail = (
-                "Model load failed (LocateAnything + transformers 5.x). "
-                "Check Space logs for the full traceback."
-            )
-        raise HTTPException(status_code=503, detail=f"Calibration failed: {detail}") from exc
-
-    if not result.get("calibrated"):
-        raise HTTPException(
-            status_code=422,
-            detail=result.get("reason", "no_hand_found"),
-        )
-    return result
-
-
-@app.delete("/api/hand/calibrate")
-def hand_clear_calibration():
-    _tracker().clear_calibration()
-    return {"ok": True}
-
-
-@app.post("/api/hand/track")
-async def hand_track(image: UploadFile = File(...)):
-    if not image.content_type or not image.content_type.startswith("image/"):
-        raise HTTPException(status_code=400, detail="Expected an image upload.")
-
-    payload = await image.read()
-    if not payload:
-        raise HTTPException(status_code=400, detail="Empty image upload.")
-
-    try:
-        return hand_track_gpu(payload)
-    except Exception as exc:  # noqa: BLE001
-        import traceback
-
-        traceback.print_exc()
-        raise HTTPException(status_code=503, detail=f"LocateAnything inference failed: {exc}") from exc
-
-
-if __name__ == "__main__":
-    app.launch(ssr_mode=False)
+with gr.Blocks(title="HandShip 3D", fill_height=True) as demo:
+    gr.Markdown(
+        """
+        # HandShip 3D
+
+        Jeu **jouable dans le navigateur** — webcam + MediaPipe + Three.js.
+        Cliquez **Jouer** dans la fenêtre ci-dessous et autorisez la caméra.
+
+        | Geste | Action |
+        |-------|--------|
+        | Direction des doigts (poignet → bouts) | Voler dans cette direction |
+        | Index levé | Boost de vitesse |
+
+        Esquivez les astéroïdes · **3 vies** · score & record local.
+        """
+    )
+    gr.HTML(
+        """
+        <iframe
+          src="/game/"
+          width="100%"
+          height="860"
+          style="border:0;border-radius:10px;background:#050810;"
+          allow="camera; microphone"
+          title="HandShip 3D"
+        ></iframe>
+        """,
+        container=False,
+    )
+
+# HF Spaces: expose ASGI `app` with static game assets at /game/
+fastapi_app = FastAPI()
+fastapi_app.mount("/game", StaticFiles(directory=str(WEB_DIR), html=True), name="game")
+app = gr.mount_gradio_app(fastapi_app, demo, path="/")

game.js

@@ -1,13 +1,6 @@
 import * as THREE from "three";
 import { loadGameAssets } from "./assets.js";
-import {
-  calibrateHand,
-  createHandTracker,
-  resetSmoothing,
-  startWebcam,
-  startWebcamPreviewLoop,
-  waitForLocateBackend,
-} from "./hand-controls.js";
+import { createHandTracker, resetSmoothing, startWebcam } from "./hand-controls.js";
 import { createAudio } from "./audio.js";
 
 const CRUISE_SPEED = 46;
@@ -37,8 +30,6 @@ const overlayTitleEl = document.getElementById("overlay-title");
 const overlayTextEl = document.getElementById("overlay-text");
 const startBtn = document.getElementById("start-btn");
 const statusEl = document.getElementById("status-msg");
-const calibrationPreviewWrap = document.getElementById("calibration-preview-wrap");
-const calibrationPreview = document.getElementById("calibration-preview");
 const flashEl = document.getElementById("hit-flash");
 const muteBtn = document.getElementById("mute-btn");
 
@@ -398,8 +389,7 @@ startBtn.addEventListener("click", async () => {
       setStatus("Accès webcam…");
       await startWebcam(video);
 
-      setStatus("Chargement nvidia/LocateAnything-3B…");
-      await waitForLocateBackend();
+      setStatus("Chargement MediaPipe…");
       handTracker = await createHandTracker(video, preview);
       bootDone = true;
       loop();
@@ -411,29 +401,6 @@ startBtn.addEventListener("click", async () => {
       audio.startEngine();
     }
     await audio.resume();
-
-    const video = document.getElementById("webcam");
-    setStatus(
-      "Calibration — montrez votre main devant la caméra… (1ère fois : chargement GPU ~1–3 min)",
-    );
-
-    if (calibrationPreviewWrap && calibrationPreview) {
-      calibrationPreviewWrap.hidden = false;
-    }
-    const stopCalibrationPreview =
-      calibrationPreview && video
-        ? startWebcamPreviewLoop(video, calibrationPreview)
-        : () => {};
-
-    try {
-      await calibrateHand(video);
-    } finally {
-      stopCalibrationPreview();
-      if (calibrationPreviewWrap) {
-        calibrationPreviewWrap.hidden = true;
-      }
-    }
-
     audio.startMusic();
     audio.playStart();
     resetGame();

hand-controls.js

@@ -1,12 +1,12 @@
 /**
- * Webcam frames → ship controls via nvidia/LocateAnything-3B (server-side).
- * The palm→index vector acts as a joystick for steering.
+ * Hand landmarks → directional control from finger-pointing direction.
+ * The wrist→fingertips vector acts as a joystick: its screen direction
+ * (mirror-corrected) becomes the ship's steering input.
  */
 
 const SMOOTHING = 0.5;
 const SENSITIVITY = 1.1;
 const INPUT_DEADZONE = 0.08;
-const TRACK_INTERVAL_MS = 300;
 
 let prev = null;
 
@@ -16,20 +16,43 @@ function shapeAxis(v) {
   return sign * ((Math.abs(v) - INPUT_DEADZONE) / (1 - INPUT_DEADZONE));
 }
 
-export function overlayToControl(overlay) {
-  if (!overlay?.palm || !overlay?.tip) {
+function fingerDirection(pts) {
+  const wrist = pts[0];
+  const tips = [8, 12, 16, 20];
+  let tipX = 0;
+  let tipY = 0;
+  for (const i of tips) {
+    tipX += pts[i].x;
+    tipY += pts[i].y;
+  }
+  tipX /= tips.length;
+  tipY /= tips.length;
+
+  const refLen = Math.hypot(pts[12].x - wrist.x, pts[12].y - wrist.y);
+  const scale = Math.max(refLen, 0.055);
+
+  const dx = (tipX - wrist.x) / scale;
+  const dy = (tipY - wrist.y) / scale;
+
+  return { wrist, tipX, tipY, dx, dy };
+}
+
+export function landmarksToControl(landmarks) {
+  if (!landmarks || landmarks.length === 0) {
     return { handDetected: false, steerX: 0, steerY: 0, throttle: 0 };
   }
 
-  const palm = overlay.palm;
-  const tip = overlay.tip;
-  const scale = 0.12;
-  const dx = (tip.x - palm.x) / scale;
-  const dy = (tip.y - palm.y) / scale;
+  const pts = landmarks[0];
+  const { dx, dy } = fingerDirection(pts);
 
+  // Webcam is mirrored: negate dx so fingers-right steers right.
+  // Screen y grows downward: negate dy so fingers-up steers up.
   const steerX = shapeAxis(Math.tanh(-dx * SENSITIVITY));
   const steerY = shapeAxis(Math.tanh(-dy * SENSITIVITY));
-  const throttle = Math.max(0, Math.min(1, (palm.y - tip.y) * 4));
+
+  const indexTip = pts[8];
+  const indexMcp = pts[5];
+  const throttle = Math.max(0, Math.min(1, (indexMcp.y - indexTip.y) * 4));
 
   function smooth(key, value) {
     if (prev === null) return value;
@@ -48,169 +71,84 @@ export function overlayToControl(overlay) {
 
 export function resetSmoothing() {
   prev = null;
-  fetch("/api/hand/reset", { method: "POST" }).catch(() => {});
-}
-
-function syncPreviewCanvasSize(videoEl, previewCanvas) {
-  const w = videoEl.videoWidth || 640;
-  const h = videoEl.videoHeight || 480;
-  if (previewCanvas.width !== w || previewCanvas.height !== h) {
-    previewCanvas.width = w;
-    previewCanvas.height = h;
-  }
 }
 
-export function drawWebcamPreview(ctx, videoEl, previewCanvas) {
-  syncPreviewCanvasSize(videoEl, previewCanvas);
-  const w = previewCanvas.width;
-  const h = previewCanvas.height;
+let landmarkerSingleton = null;
 
-  ctx.save();
-  ctx.scale(-1, 1);
-  ctx.drawImage(videoEl, -w, 0, w, h);
-  ctx.restore();
-}
+async function createLandmarker(delegate) {
+  const { HandLandmarker, FilesetResolver } = await import(
+    "https://cdn.jsdelivr.net/npm/@mediapipe/tasks-vision@0.10.14/+esm"
+  );
 
-/** Live mirrored webcam feed on a canvas (e.g. during calibration). */
-export function startWebcamPreviewLoop(videoEl, previewCanvas) {
-  const ctx = previewCanvas.getContext("2d");
-  let running = true;
-  let rafId = 0;
+  const vision = await FilesetResolver.forVisionTasks(
+    "https://cdn.jsdelivr.net/npm/@mediapipe/tasks-vision@0.10.14/wasm"
+  );
 
-  const tick = () => {
-    if (!running) return;
-    if (videoEl.readyState >= 2) {
-      drawWebcamPreview(ctx, videoEl, previewCanvas);
-    }
-    rafId = requestAnimationFrame(tick);
-  };
-
-  rafId = requestAnimationFrame(tick);
-  return () => {
-    running = false;
-    cancelAnimationFrame(rafId);
-  };
-}
-
-function drawPreview(ctx, videoEl, previewCanvas, overlay) {
-  drawWebcamPreview(ctx, videoEl, previewCanvas);
-
-  if (!overlay?.palm || !overlay?.tip) return;
-
-  const w = previewCanvas.width;
-  const h = previewCanvas.height;
-  const wx = (1 - overlay.palm.x) * w;
-  const wy = overlay.palm.y * h;
-  const tx = (1 - overlay.tip.x) * w;
-  const ty = overlay.tip.y * h;
-
-  ctx.strokeStyle = "#00ff88";
-  ctx.lineWidth = 3;
-  ctx.beginPath();
-  ctx.moveTo(wx, wy);
-  ctx.lineTo(tx, ty);
-  ctx.stroke();
-
-  ctx.fillStyle = "#00ff88";
-  ctx.beginPath();
-  ctx.arc(tx, ty, 5, 0, Math.PI * 2);
-  ctx.fill();
-}
-
-async function captureFrameBlob(videoEl) {
-  const w = videoEl.videoWidth;
-  const h = videoEl.videoHeight;
-  if (!w || !h) return null;
-
-  const capture = document.createElement("canvas");
-  capture.width = w;
-  capture.height = h;
-  const captureCtx = capture.getContext("2d");
-  captureCtx.scale(-1, 1);
-  captureCtx.drawImage(videoEl, -w, 0, w, h);
-
-  return new Promise((resolve) => {
-    capture.toBlob((blob) => resolve(blob), "image/jpeg", 0.82);
+  return HandLandmarker.createFromOptions(vision, {
+    baseOptions: {
+      modelAssetPath:
+        "https://storage.googleapis.com/mediapipe-models/hand_landmarker/hand_landmarker/float16/1/hand_landmarker.task",
+      delegate,
+    },
+    runningMode: "VIDEO",
+    numHands: 1,
   });
 }
 
-export async function calibrateHand(videoEl) {
-  const blob = await captureFrameBlob(videoEl);
-  if (!blob) {
-    throw new Error("Webcam frame unavailable for calibration.");
-  }
-
-  const form = new FormData();
-  form.append("image", blob, "calibration.jpg");
-  const response = await fetch("/api/hand/calibrate", { method: "POST", body: form });
-  if (!response.ok) {
-    const detail = await response.text();
-    let message = detail;
+export async function createHandTracker(videoEl, previewCanvas) {
+  if (!landmarkerSingleton) {
     try {
-      const parsed = JSON.parse(detail);
-      if (parsed?.detail) message = String(parsed.detail);
+      landmarkerSingleton = await createLandmarker("GPU");
     } catch {
-      // keep raw text
+      landmarkerSingleton = await createLandmarker("CPU");
     }
-    if (response.status === 422 || message.includes("no_hand_found")) {
-      throw new Error("Main non détectée — montrez votre main clairement devant la caméra.");
-    }
-    if (response.status === 503) {
-      throw new Error(
-        "Le modèle LocateAnything n'a pas pu s'exécuter. Réessayez dans une minute.",
-      );
-    }
-    throw new Error(message || `Calibration failed (${response.status})`);
   }
-  return response.json();
-}
+  const landmarker = landmarkerSingleton;
 
-export async function createHandTracker(videoEl, previewCanvas) {
   const ctx = previewCanvas.getContext("2d");
+  let lastVideoTime = -1;
   let lastPacket = { handDetected: false, steerX: 0, steerY: 0, throttle: 0 };
-  let lastOverlay = null;
-  let inFlight = false;
-  let lastTrackAt = 0;
-
-  async function trackFrame() {
-    if (inFlight || videoEl.readyState < 2) return;
-    const now = performance.now();
-    if (now - lastTrackAt < TRACK_INTERVAL_MS) return;
-
-    const blob = await captureFrameBlob(videoEl);
-    if (!blob) return;
-
-    inFlight = true;
-    lastTrackAt = now;
-
-    try {
-      const form = new FormData();
-      form.append("image", blob, "frame.jpg");
-      const response = await fetch("/api/hand/track", { method: "POST", body: form });
-      if (!response.ok) {
-        const detail = await response.text();
-        throw new Error(detail || `HTTP ${response.status}`);
-      }
-
-      const data = await response.json();
-      lastOverlay = data.overlay ?? null;
-      lastPacket = {
-        handDetected: Boolean(data.handDetected),
-        steerX: data.steerX ?? 0,
-        steerY: data.steerY ?? 0,
-        throttle: data.throttle ?? 0,
-      };
-    } catch (err) {
-      console.warn("[LocateAnything-3B]", err);
-    } finally {
-      inFlight = false;
-    }
-  }
 
   return {
     async detect() {
-      trackFrame();
-      drawPreview(ctx, videoEl, previewCanvas, lastOverlay);
+      if (videoEl.readyState < 2) {
+        return lastPacket;
+      }
+      if (videoEl.currentTime === lastVideoTime) {
+        return lastPacket;
+      }
+      lastVideoTime = videoEl.currentTime;
+      const result = landmarker.detectForVideo(videoEl, performance.now());
+      lastPacket = landmarksToControl(result.landmarks);
+
+      const w = previewCanvas.width;
+      const h = previewCanvas.height;
+      // Mirror the preview so it behaves like a mirror for the user.
+      ctx.save();
+      ctx.scale(-1, 1);
+      ctx.drawImage(videoEl, -w, 0, w, h);
+      ctx.restore();
+
+      if (result.landmarks?.[0]) {
+        const pts = result.landmarks[0];
+        const { wrist, tipX, tipY } = fingerDirection(pts);
+        const wx = (1 - wrist.x) * w;
+        const wy = wrist.y * h;
+        const tx = (1 - tipX) * w;
+        const ty = tipY * h;
+
+        ctx.strokeStyle = "#00ff88";
+        ctx.lineWidth = 3;
+        ctx.beginPath();
+        ctx.moveTo(wx, wy);
+        ctx.lineTo(tx, ty);
+        ctx.stroke();
+
+        ctx.fillStyle = "#00ff88";
+        ctx.beginPath();
+        ctx.arc(tx, ty, 5, 0, Math.PI * 2);
+        ctx.fill();
+      }
       return lastPacket;
     },
   };
@@ -224,15 +162,3 @@ export async function startWebcam(videoEl) {
   videoEl.srcObject = stream;
   await videoEl.play();
 }
-
-export async function waitForLocateBackend() {
-  const response = await fetch("/api/hand/status");
-  if (!response.ok) {
-    throw new Error("LocateAnything backend unavailable.");
-  }
-  const status = await response.json();
-  if (!status.cudaAvailable && !status.loaded) {
-    console.warn("[LocateAnything-3B] CUDA not available — inference will be very slow on CPU.");
-  }
-  return status;
-}

index.html

@@ -49,22 +49,6 @@
       background: #4cc9f0; border: none; border-radius: 8px; color: #051018;
       font-weight: 600;
     }
-    #calibration-preview-wrap {
-      margin-top: 16px;
-    }
-    #calibration-preview-wrap[hidden] {
-      display: none !important;
-    }
-    #calibration-preview {
-      display: block;
-      width: min(92vw, 520px);
-      max-height: min(52vh, 390px);
-      margin: 0 auto;
-      border: 2px solid #4cc9f0;
-      border-radius: 8px;
-      background: #000;
-      object-fit: contain;
-    }
   </style>
   <script type="importmap">
   {
@@ -82,16 +66,9 @@
       <p id="overlay-text">Allow the webcam and dodge the asteroids.</p>
       <p style="margin-top:8px;font-size:14px;opacity:0.8">
         Point your fingers in the direction you want to fly — the ship follows.<br/>
-        Fingers up = climb · Raised index finger = boost<br/>
-        <span style="opacity:0.7">At start, show your hand to calibrate tracking (LocateAnything-3B)</span>
+        Fingers up = climb · Raised index finger = boost
       </p>
       <p id="status-msg" style="margin-top:12px;font-size:14px;color:#a8e8ff;min-height:1.2em"></p>
-      <div id="calibration-preview-wrap" hidden>
-        <canvas id="calibration-preview" width="640" height="480"></canvas>
-        <p style="margin-top:8px;font-size:13px;opacity:0.85">
-          Cadre miroir — alignez votre main paume ouverte face à la caméra
-        </p>
-      </div>
       <button id="start-btn">Play</button>
     </div>
   </div>

requirements.txt

@@ -1,18 +1,2 @@
-# Build tooling (HF Spaces Python 3.11)
-setuptools>=69.0.0
-wheel>=0.42.0
-
-# Do NOT pin: gradio, spaces, torch, huggingface-hub (managed by HF / ZeroGPU runtime)
-
-# LocateAnything-3B — transformers 5.x required for huggingface-hub 1.x (Gradio 6.19)
-transformers>=5.0,<6
-accelerate>=0.26.0
-safetensors>=0.4.0
-peft>=0.10.0
-torchvision
-decord==0.6.0
-lmdb==1.7.5
-opencv-python-headless==4.11.0.86
-numpy>=1.26.0,<2.0
-Pillow>=11.1.0
-python-multipart>=0.0.9
+# Gradio, FastAPI, and uvicorn are preinstalled on HF Spaces.
+# Pinning them here causes version conflicts with huggingface_hub.

services/__init__.py

@@ -1 +0,0 @@
-"""HandShip backend services."""

services/locate/__init__.py

@@ -1,19 +0,0 @@
-"""LocateAnything-3B hand tracking service."""
-
-from .hand_tracker import (
-    calibrate_from_frame,
-    clear_calibration,
-    frame_to_control,
-    get_worker,
-    reset_smoothing,
-    worker_status,
-)
-
-__all__ = [
-    "calibrate_from_frame",
-    "clear_calibration",
-    "frame_to_control",
-    "get_worker",
-    "reset_smoothing",
-    "worker_status",
-]

services/locate/hand_tracker.py

@@ -1,329 +0,0 @@
-"""Map webcam frames to ship controls via nvidia/LocateAnything-3B."""
-
-from __future__ import annotations
-
-import io
-import math
-import os
-import time
-from typing import Any, Literal, Optional
-
-import torch
-from PIL import Image
-
-from .locateanything_worker import LocateAnythingWorker
-
-MODEL_ID = os.environ.get("LOCATE_MODEL_ID", "nvidia/LocateAnything-3B")
-GENERATION_MODE = os.environ.get("LOCATE_GENERATION_MODE", "hybrid")
-MAX_NEW_TOKENS = int(os.environ.get("LOCATE_MAX_NEW_TOKENS", "512"))
-SENSITIVITY = float(os.environ.get("LOCATE_SENSITIVITY", "1.1"))
-DEADZONE = float(os.environ.get("LOCATE_DEADZONE", "0.08"))
-SMOOTHING = float(os.environ.get("LOCATE_SMOOTHING", "0.5"))
-HAND_PROMPT = os.environ.get(
-    "LOCATE_HAND_PROMPT",
-    "the hand closest to the camera",
-)
-FINGER_PROMPT = os.environ.get(
-    "LOCATE_FINGER_PROMPT",
-    "the index fingertip of the same hand",
-)
-HAND_SELECT = os.environ.get("LOCATE_HAND_SELECT", "temporal").lower()
-CALIBRATION_PADDING = float(os.environ.get("LOCATE_CALIBRATION_PADDING", "0.12"))
-
-SelectMode = Literal["largest", "center", "temporal"]
-
-_worker: Optional[LocateAnythingWorker] = None
-_visual_prompt: Optional[Image.Image] = None
-_prev_smooth: dict[str, float] = {}
-_prev_palm: Optional[tuple[float, float]] = None
-
-
-def get_worker() -> LocateAnythingWorker:
-    global _worker
-    if _worker is None:
-        device = os.environ.get("LOCATE_DEVICE")
-        if not device:
-            if os.environ.get("SPACES_ZERO_GPU") == "1" or torch.cuda.is_available():
-                device = "cuda"
-            else:
-                device = "cpu"
-        dtype = torch.bfloat16 if device != "cpu" else torch.float32
-        _worker = LocateAnythingWorker(MODEL_ID, device=device, dtype=dtype)
-    return _worker
-
-
-def worker_status() -> dict[str, Any]:
-    device = os.environ.get("LOCATE_DEVICE")
-    if not device:
-        device = "cuda" if torch.cuda.is_available() else "cpu"
-    return {
-        "modelId": MODEL_ID,
-        "loaded": _worker is not None,
-        "device": device,
-        "cudaAvailable": torch.cuda.is_available(),
-        "generationMode": GENERATION_MODE,
-        "api": "transformers.AutoModel(trust_remote_code=True)",
-        "backend": "gradio-zerogpu",
-        "handPrompt": HAND_PROMPT,
-        "fingerPrompt": FINGER_PROMPT,
-        "handSelect": HAND_SELECT,
-        "calibrated": _visual_prompt is not None,
-    }
-
-
-def reset_smoothing() -> None:
-    global _prev_smooth, _prev_palm
-    _prev_smooth = {}
-    _prev_palm = None
-
-
-def clear_calibration() -> None:
-    global _visual_prompt
-    _visual_prompt = None
-    reset_smoothing()
-
-
-def _shape_axis(value: float) -> float:
-    if abs(value) < DEADZONE:
-        return 0.0
-    sign = 1.0 if value >= 0 else -1.0
-    return sign * ((abs(value) - DEADZONE) / (1.0 - DEADZONE))
-
-
-def _smooth(key: str, value: float) -> float:
-    if key not in _prev_smooth:
-        _prev_smooth[key] = value
-        return value
-    blended = _prev_smooth[key] * (1.0 - SMOOTHING) + value * SMOOTHING
-    _prev_smooth[key] = blended
-    return blended
-
-
-def _box_center(box: dict) -> tuple[float, float]:
-    return ((box["x1"] + box["x2"]) / 2.0, (box["y1"] + box["y2"]) / 2.0)
-
-
-def _box_area(box: dict) -> float:
-    return max(0.0, box["x2"] - box["x1"]) * max(0.0, box["y2"] - box["y1"])
-
-
-def _select_hand_box(
-    boxes: list[dict],
-    width: int,
-    height: int,
-    mode: SelectMode,
-) -> Optional[dict]:
-    if not boxes:
-        return None
-
-    if mode == "largest":
-        return max(boxes, key=_box_area)
-
-    if mode == "center":
-        cx, cy = width / 2.0, height / 2.0
-        return min(boxes, key=lambda box: math.hypot(_box_center(box)[0] - cx, _box_center(box)[1] - cy))
-
-    if _prev_palm is not None:
-        px = _prev_palm[0] * width
-        py = _prev_palm[1] * height
-        return min(
-            boxes,
-            key=lambda box: math.hypot(_box_center(box)[0] - px, _box_center(box)[1] - py),
-        )
-
-    cx, cy = width / 2.0, height / 2.0
-    return min(boxes, key=lambda box: math.hypot(_box_center(box)[0] - cx, _box_center(box)[1] - cy))
-
-
-def _crop_hand_box(image: Image.Image, box: dict, padding: float = CALIBRATION_PADDING) -> Image.Image:
-    width, height = image.size
-    pad_x = (box["x2"] - box["x1"]) * padding
-    pad_y = (box["y2"] - box["y1"]) * padding
-    left = max(0, int(box["x1"] - pad_x))
-    top = max(0, int(box["y1"] - pad_y))
-    right = min(width, int(box["x2"] + pad_x))
-    bottom = min(height, int(box["y2"] + pad_y))
-    if right <= left or bottom <= top:
-        return image.crop((int(box["x1"]), int(box["y1"]), int(box["x2"]), int(box["y2"]))).convert("RGB")
-    return image.crop((left, top, right, bottom)).convert("RGB")
-
-
-def _point_in_box(point: dict, box: dict, margin_ratio: float = 0.35) -> bool:
-    width = max(box["x2"] - box["x1"], 1.0)
-    height = max(box["y2"] - box["y1"], 1.0)
-    margin_x = width * margin_ratio
-    margin_y = height * margin_ratio
-    return (
-        box["x1"] - margin_x <= point["x"] <= box["x2"] + margin_x
-        and box["y1"] - margin_y <= point["y"] <= box["y2"] + margin_y
-    )
-
-
-def _select_fingertip(points: list[dict], hand_box: Optional[dict]) -> Optional[dict]:
-    if not points:
-        return None
-    if hand_box is None:
-        return min(points, key=lambda point: point["y"])
-    inside = [point for point in points if _point_in_box(point, hand_box)]
-    pool = inside or points
-    return min(pool, key=lambda point: point["y"])
-
-
-def _infer_hand_box(
-    worker: LocateAnythingWorker,
-    image: Image.Image,
-    width: int,
-    height: int,
-) -> tuple[Optional[dict], str]:
-    select_mode: SelectMode = HAND_SELECT if HAND_SELECT in {"largest", "center", "temporal"} else "temporal"
-
-    if _visual_prompt is not None:
-        result = worker.detect_visual_prompt(
-            image,
-            _visual_prompt,
-            generation_mode=GENERATION_MODE,
-            max_new_tokens=MAX_NEW_TOKENS,
-            verbose=False,
-        )
-        source = "visual_prompt"
-    else:
-        result = worker.ground_single(
-            image,
-            HAND_PROMPT,
-            generation_mode=GENERATION_MODE,
-            max_new_tokens=MAX_NEW_TOKENS,
-            verbose=False,
-        )
-        source = "ground_single"
-
-    boxes = LocateAnythingWorker.parse_boxes(result["answer"], width, height)
-    hand_box = _select_hand_box(boxes, width, height, select_mode)
-    return hand_box, source
-
-
-def calibrate_from_frame(image_bytes: bytes) -> dict[str, Any]:
-    """Capture the player's hand once and store a visual prompt for later frames."""
-    global _visual_prompt, _prev_palm
-
-    image = Image.open(io.BytesIO(image_bytes)).convert("RGB")
-    width, height = image.size
-    worker = get_worker()
-    started = time.perf_counter()
-
-    result = worker.ground_single(
-        image,
-        HAND_PROMPT,
-        generation_mode=GENERATION_MODE,
-        max_new_tokens=MAX_NEW_TOKENS,
-        verbose=False,
-    )
-    boxes = LocateAnythingWorker.parse_boxes(result["answer"], width, height)
-    hand_box = _select_hand_box(boxes, width, height, "center")
-
-    if hand_box is None:
-        return {
-            "calibrated": False,
-            "reason": "no_hand_found",
-            "handPrompt": HAND_PROMPT,
-            "latencyMs": int((time.perf_counter() - started) * 1000),
-        }
-
-    _visual_prompt = _crop_hand_box(image, hand_box)
-    palm_x, palm_y = _box_center(hand_box)
-    _prev_palm = (palm_x / width, palm_y / height)
-    reset_smoothing()
-
-    return {
-        "calibrated": True,
-        "handPrompt": HAND_PROMPT,
-        "handSelect": HAND_SELECT,
-        "latencyMs": int((time.perf_counter() - started) * 1000),
-        "overlay": {
-            "palm": {"x": _prev_palm[0], "y": _prev_palm[1]},
-            "tip": {"x": _prev_palm[0], "y": max(0.0, _prev_palm[1] - 0.08)},
-        },
-    }
-
-
-def frame_to_control(image_bytes: bytes) -> dict[str, Any]:
-    """Run LocateAnything on a JPEG/PNG frame and return a game control packet."""
-    global _prev_palm
-
-    image = Image.open(io.BytesIO(image_bytes)).convert("RGB")
-    width, height = image.size
-    worker = get_worker()
-    started = time.perf_counter()
-
-    hand_box, hand_source = _infer_hand_box(worker, image, width, height)
-
-    finger_result = worker.point(
-        image,
-        FINGER_PROMPT,
-        generation_mode=GENERATION_MODE,
-        max_new_tokens=MAX_NEW_TOKENS,
-        verbose=False,
-    )
-    points = LocateAnythingWorker.parse_points(finger_result["answer"], width, height)
-    latency_ms = int((time.perf_counter() - started) * 1000)
-
-    if hand_box is None and not points:
-        return {
-            "handDetected": False,
-            "steerX": 0.0,
-            "steerY": 0.0,
-            "throttle": 0.0,
-            "latencyMs": latency_ms,
-            "overlay": None,
-            "source": "locateanything-3b",
-            "calibrated": _visual_prompt is not None,
-            "handSource": hand_source,
-        }
-
-    if hand_box:
-        palm_x, palm_y = _box_center(hand_box)
-        hand_span = max(hand_box["y2"] - hand_box["y1"], height * 0.05)
-    elif points:
-        palm_x = points[0]["x"]
-        palm_y = points[0]["y"]
-        hand_span = height * 0.12
-    else:
-        palm_x = width * 0.5
-        palm_y = height * 0.5
-        hand_span = height * 0.12
-
-    fingertip = _select_fingertip(points, hand_box)
-    if fingertip:
-        tip_x = fingertip["x"]
-        tip_y = fingertip["y"]
-    else:
-        tip_x = palm_x
-        tip_y = palm_y - hand_span * 0.35
-
-    palm_x_norm = max(0.0, min(1.0, palm_x / width))
-    palm_y_norm = max(0.0, min(1.0, palm_y / height))
-    tip_x_norm = max(0.0, min(1.0, tip_x / width))
-    tip_y_norm = max(0.0, min(1.0, tip_y / height))
-    _prev_palm = (palm_x_norm, palm_y_norm)
-
-    scale = max(hand_span / height, 0.055)
-    dx = (tip_x_norm - palm_x_norm) / scale
-    dy = (tip_y_norm - palm_y_norm) / scale
-
-    steer_x = _shape_axis(math.tanh(-dx * SENSITIVITY))
-    steer_y = _shape_axis(math.tanh(-dy * SENSITIVITY))
-    throttle = max(0.0, min(1.0, (palm_y_norm - tip_y_norm) * 4.0))
-
-    return {
-        "handDetected": True,
-        "steerX": _smooth("steerX", steer_x),
-        "steerY": _smooth("steerY", steer_y),
-        "throttle": _smooth("throttle", throttle),
-        "latencyMs": latency_ms,
-        "overlay": {
-            "palm": {"x": palm_x_norm, "y": palm_y_norm},
-            "tip": {"x": tip_x_norm, "y": tip_y_norm},
-        },
-        "source": "locateanything-3b",
-        "calibrated": _visual_prompt is not None,
-        "handSource": hand_source,
-    }

services/locate/locateanything_worker.py

@@ -1,152 +0,0 @@
-# Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved.
-#
-# nvidia/LocateAnything-3B requires AutoModel + trust_remote_code — not the generic
-# image-text-to-text pipeline (LocateAnythingConfig is not registered there).
-
-from __future__ import annotations
-
-import re
-from typing import Any, Optional, Sequence, Union
-
-import torch
-from PIL import Image
-from transformers import AutoConfig, AutoModel, AutoProcessor, AutoTokenizer
-
-from .transformers_compat import (
-    apply_locateanything_transformers5_compat,
-    patch_locateanything_config,
-)
-
-
-class LocateAnythingWorker:
-    """Stateful worker that loads nvidia/LocateAnything-3B once and serves queries."""
-
-    def __init__(
-        self,
-        model_path: str,
-        device: str = "cuda",
-        dtype: torch.dtype = torch.bfloat16,
-    ) -> None:
-        device_arg = device
-        if device == "cuda" and not torch.cuda.is_available():
-            device_arg = "cpu"
-            dtype = torch.float32
-
-        self.device = device_arg
-        self.dtype = dtype
-        apply_locateanything_transformers5_compat()
-        self.tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
-        self.processor = AutoProcessor.from_pretrained(model_path, trust_remote_code=True)
-        config = AutoConfig.from_pretrained(model_path, trust_remote_code=True)
-        patch_locateanything_config(config)
-        self.model = AutoModel.from_pretrained(
-            model_path,
-            config=config,
-            dtype=dtype,
-            trust_remote_code=True,
-        ).to(device_arg).eval()
-
-    @torch.no_grad()
-    def _run(
-        self,
-        image: Image.Image,
-        question: str,
-        generation_mode: str = "hybrid",
-        max_new_tokens: int = 2048,
-        temperature: float = 0.7,
-        verbose: bool = False,
-        visual_prompt: Optional[Union[Image.Image, Sequence[Image.Image]]] = None,
-    ) -> dict[str, Any]:
-        content: list[dict] = [
-            {"type": "image", "image": image.convert("RGB")},
-            {"type": "text", "text": question},
-        ]
-        if visual_prompt is not None:
-            prompts = [visual_prompt] if isinstance(visual_prompt, Image.Image) else list(visual_prompt)
-            for prompt_image in prompts:
-                content.append({"type": "image", "image": prompt_image.convert("RGB")})
-
-        messages = [{"role": "user", "content": content}]
-        text = self.processor.py_apply_chat_template(
-            messages, tokenize=False, add_generation_prompt=True
-        )
-        images, videos = self.processor.process_vision_info(messages)
-        inputs = self.processor(
-            text=[text], images=images, videos=videos, return_tensors="pt"
-        ).to(self.device)
-
-        pixel_values = inputs["pixel_values"].to(self.dtype)
-        generate_kwargs: dict[str, Any] = {
-            "pixel_values": pixel_values,
-            "input_ids": inputs["input_ids"],
-            "attention_mask": inputs["attention_mask"],
-            "image_grid_hws": inputs.get("image_grid_hws"),
-            "tokenizer": self.tokenizer,
-            "max_new_tokens": max_new_tokens,
-            "use_cache": True,
-            "generation_mode": generation_mode,
-            "temperature": temperature,
-            "do_sample": temperature > 0,
-            "top_p": 0.9,
-            "repetition_penalty": 1.1,
-            "verbose": verbose,
-        }
-
-        response = self.model.generate(**generate_kwargs)
-        if response is None:
-            return {"answer": ""}
-        answer = response[0] if isinstance(response, tuple) else response
-        if answer is None:
-            answer = ""
-        result: dict[str, Any] = {"answer": answer}
-        if isinstance(response, tuple) and len(response) >= 3:
-            result["history"] = response[1]
-            result["stats"] = response[2]
-        return result
-
-    def ground_single(self, image: Image.Image, phrase: str, **kwargs) -> dict:
-        prompt = f"Locate a single instance that matches the following description: {phrase}."
-        return self._run(image, prompt, **kwargs)
-
-    def point(self, image: Image.Image, phrase: str, **kwargs) -> dict:
-        prompt = f"Point to: {phrase}."
-        return self._run(image, prompt, **kwargs)
-
-    def detect_visual_prompt(
-        self,
-        image: Image.Image,
-        visual_prompt: Image.Image,
-        **kwargs,
-    ) -> dict:
-        prompt = (
-            "Detect all the objects in the image that belong to the category set: <visual_prompt>."
-        )
-        return self._run(image, prompt, visual_prompt=visual_prompt, **kwargs)
-
-    @staticmethod
-    def parse_boxes(answer: str, image_width: int, image_height: int) -> list[dict]:
-        boxes = []
-        for match in re.finditer(r"<box><(\d+)><(\d+)><(\d+)><(\d+)></box>", answer):
-            x1, y1, x2, y2 = (int(group) for group in match.groups())
-            boxes.append(
-                {
-                    "x1": x1 / 1000 * image_width,
-                    "y1": y1 / 1000 * image_height,
-                    "x2": x2 / 1000 * image_width,
-                    "y2": y2 / 1000 * image_height,
-                }
-            )
-        return boxes
-
-    @staticmethod
-    def parse_points(answer: str, image_width: int, image_height: int) -> list[dict]:
-        points = []
-        for match in re.finditer(r"<box><(\d+)><(\d+)></box>", answer):
-            x, y = int(match.group(1)), int(match.group(2))
-            points.append(
-                {
-                    "x": x / 1000 * image_width,
-                    "y": y / 1000 * image_height,
-                }
-            )
-        return points

services/locate/transformers_compat.py

@@ -1,171 +0,0 @@
-"""Shims for loading nvidia/LocateAnything-3B under transformers 5.x on HF Spaces."""
-
-from __future__ import annotations
-
-import inspect
-
-
-def _find_attn_check_method(cls: type):
-    for candidate in cls.mro():
-        method = candidate.__dict__.get("_check_and_adjust_attn_implementation")
-        if method is not None:
-            return method
-    return None
-
-
-def _needs_attn_compat(method) -> bool:
-    if isinstance(method, classmethod):
-        fn = method.__func__
-    elif isinstance(method, staticmethod):
-        fn = method.__func__
-    else:
-        fn = method
-
-    try:
-        signature = inspect.signature(fn)
-    except (TypeError, ValueError):
-        return False
-
-    accepts_var_kw = any(
-        param.kind == inspect.Parameter.VAR_KEYWORD
-        for param in signature.parameters.values()
-    )
-    return not accepts_var_kw and "allow_all_kernels" not in signature.parameters
-
-
-def _instance_attn_compat(self, method):
-    if isinstance(method, classmethod):
-        fn = method.__func__
-        signature = inspect.signature(fn)
-
-        def compat(*args, **kwargs):
-            kwargs.pop("allow_all_kernels", None)
-            filtered = {
-                key: value for key, value in kwargs.items() if key in signature.parameters
-            }
-            return fn(type(self), *args, **filtered)
-
-        return compat
-
-    if isinstance(method, staticmethod):
-        fn = method.__func__
-    else:
-        fn = method
-
-    signature = inspect.signature(fn)
-
-    def compat(*args, **kwargs):
-        kwargs.pop("allow_all_kernels", None)
-        filtered = {
-            key: value for key, value in kwargs.items() if key in signature.parameters
-        }
-        return fn(self, *args, **filtered)
-
-    return compat
-
-
-def apply_locateanything_transformers5_compat() -> None:
-    """Strip kwargs that transformers 5 passes but LocateAnything remote code rejects."""
-    import transformers.modeling_utils as modeling_utils
-
-    if getattr(modeling_utils.PreTrainedModel, "_la_compat_applied", False):
-        return
-
-    original_init = modeling_utils.PreTrainedModel.__init__
-    original_post_init = modeling_utils.PreTrainedModel.post_init
-    original_finalize = modeling_utils.PreTrainedModel._finalize_model_loading
-
-    @staticmethod
-    def _finalize_model_loading(model, load_config, loading_info):
-        if not hasattr(model, "all_tied_weights_keys") and hasattr(model, "post_init"):
-            post_init(model)
-        return original_finalize(model, load_config, loading_info)
-
-    def post_init(self, *args, **kwargs):
-        tied = getattr(self, "_tied_weights_keys", None)
-        if isinstance(tied, list):
-            if tied == ["lm_head.weight"]:
-                mapping = {"lm_head.weight": "model.embed_tokens.weight"}
-            else:
-                mapping = {}
-            object.__setattr__(self, "_tied_weights_keys", mapping)
-        return original_post_init(self, *args, **kwargs)
-
-    def __init__(self, config, *args, **kwargs):
-        method = _find_attn_check_method(type(self))
-        if method is not None and _needs_attn_compat(method):
-            object.__setattr__(
-                self,
-                "_check_and_adjust_attn_implementation",
-                _instance_attn_compat(self, method),
-            )
-        return original_init(self, config, *args, **kwargs)
-
-    modeling_utils.PreTrainedModel.__init__ = __init__
-    modeling_utils.PreTrainedModel.post_init = post_init
-    modeling_utils.PreTrainedModel._finalize_model_loading = _finalize_model_loading
-    modeling_utils.PreTrainedModel._la_compat_applied = True
-
-    _patch_dynamic_cache_legacy()
-
-
-def _patch_dynamic_cache_legacy() -> None:
-    from transformers.cache_utils import DynamicCache, DynamicLayer
-
-    if getattr(DynamicCache, "_la_legacy_patched", False):
-        return
-
-    def to_legacy_cache(self):
-        legacy = []
-        for layer in self.layers:
-            if getattr(layer, "is_initialized", False):
-                legacy.append((layer.keys, layer.values))
-        return tuple(legacy)
-
-    @classmethod
-    def from_legacy_cache(cls, past_key_values):
-        cache = cls()
-        cache.layers = []
-        for key_states, value_states in past_key_values:
-            layer = DynamicLayer()
-            if key_states is not None and value_states is not None:
-                layer.keys = key_states
-                layer.values = value_states
-                layer.is_initialized = True
-                layer.dtype = key_states.dtype
-                layer.device = key_states.device
-            cache.layers.append(layer)
-        return cache
-
-    DynamicCache.to_legacy_cache = to_legacy_cache
-    DynamicCache.from_legacy_cache = from_legacy_cache
-    DynamicCache._la_legacy_patched = True
-
-
-def patch_locateanything_config(config) -> None:
-    """Restore nested Qwen2 fields dropped by transformers 5 config hydration."""
-    text_config = getattr(config, "text_config", None)
-    if text_config is None:
-        return
-
-    raw = text_config.to_dict() if hasattr(text_config, "to_dict") else {}
-    required_fields = {
-        "rope_theta": 1_000_000.0,
-        "max_position_embeddings": 32768,
-        "num_hidden_layers": 36,
-        "num_attention_heads": 16,
-        "num_key_value_heads": 2,
-        "hidden_size": 2048,
-        "intermediate_size": 11008,
-        "vocab_size": 152681,
-    }
-
-    for key, default in required_fields.items():
-        value = raw.get(key, default)
-        try:
-            getattr(text_config, key)
-        except AttributeError:
-            object.__setattr__(text_config, key, value)
-
-    if getattr(text_config, "_attn_implementation", None) in (None, "sdpa", "eager"):
-        object.__setattr__(text_config, "_attn_implementation", "magi")