Add json import to app.py for JSON handling

app.py

@@ -1,5 +1,6 @@
 import gradio as gr
 import tempfile
+import json
 import shutil
 import os
 import cv2

blade-inspection-demo/gptoss_wrapper.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+import os
+import json
+import requests
+from typing import Optional
+
+class GPTOSSWrapper:
+    """
+    Lightweight wrapper to call the GPT-OSS 120 model via HuggingFace Inference API.
+    Supports CPU-only workflows by using the public inference endpoint and an optional HF token.
+    """
+    def __init__(self, model: str = "gpt-oss-120", token: Optional[str] = None, base_url: Optional[str] = None, timeout: int = 60):
+        self.model = model
+        self.base_url = base_url or f"https://api-inference.huggingface.co/models/{model}"
+        self.token = token or os.environ.get("HF_API_TOKEN")
+        self.session = requests.Session()
+        self.timeout = timeout
+
+    def _headers(self) -> dict:
+        headers = {"Accept": "application/json"}
+        if self.token:
+            headers["Authorization"] = f"Bearer {self.token}"
+        return headers
+
+    def generate(self, prompt: str, max_new_tokens: int = 1024, temperature: float = 0.3, top_p: float = 0.9) -> str:
+        """
+        Send the prompt to the GPT-OSS 120 model and return generated text.
+        Tries a couple of payload shapes to maximize compatibility with HF Inference API responses.
+        """
+        payloads = [
+            {"inputs": prompt, "parameters": {"max_new_tokens": max_new_tokens, "temperature": temperature, "top_p": top_p}},
+            {"inputs": {"prompt": prompt}, "options": {"wait_for_model": True}, "parameters": {"max_new_tokens": max_new_tokens, "temperature": temperature}}
+        ]
+        last_err = None
+        for payload in payloads:
+            try:
+                resp = self.session.post(self.base_url, headers=self._headers(), json=payload, timeout=self.timeout)
+                resp.raise_for_status()
+                data = resp.json()
+                # Normalize possible response shapes
+                if isinstance(data, dict):
+                    if "generated_text" in data:
+                        return data["generated_text"]
+                    if "choices" in data and isinstance(data["choices"], list) and data["choices"]:
+                        first = data["choices"][0]
+                        if isinstance(first, dict):
+                            if "text" in first:
+                                return first["text"]
+                            if "generated_text" in first:
+                                return first["generated_text"]
+                if isinstance(data, str):
+                    return data
+                return json.dumps(data, indent=2)
+            except Exception as e:
+                last_err = e
+                continue
+        return f"Error calling GPT-OSS: {last_err}"
+
+# Simple convenience function
+def generate_report_text(prompt: str, token: Optional[str] = None, model: str = "gpt-oss-120") -> str:
+    wrapper = GPTOSSWrapper(model=model, token=token)
+    return wrapper.generate(prompt)