Update question_support_loader.py

question_support_loader.py

@@ -2,57 +2,70 @@ from __future__ import annotations
 
 import json
 from pathlib import Path
-from typing import Any, Dict, Optional
-
-
-BASE_DIR = Path(__file__).resolve().parent
-DATA_DIR = BASE_DIR / "data"
-QUESTION_SUPPORT_PATH = DATA_DIR / "question_support_bank.jsonl"
+from typing import Any, Dict, List, Optional
 
 
 class QuestionSupportBank:
-    def __init__(self, path: Path | None = None):
-        self.path = path or QUESTION_SUPPORT_PATH
-        self._by_id: Dict[str, Dict[str, Any]] = {}
+    def __init__(self, data_path: Optional[str] = None) -> None:
+        base_dir = Path(__file__).resolve().parent
+        self.data_path = Path(data_path) if data_path else base_dir / "data" / "question_support_bank.jsonl"
         self._loaded = False
+        self._by_id: Dict[str, Dict[str, Any]] = {}
+        self._by_text: Dict[str, Dict[str, Any]] = {}
+
+    def _normalize(self, text: Optional[str]) -> str:
+        return " ".join((text or "").strip().lower().split())
 
     def load(self) -> None:
         self._by_id = {}
-
-        if not self.path.exists():
-            self._loaded = True
-            return
-
-        with self.path.open("r", encoding="utf-8") as f:
-            for line_number, line in enumerate(f, start=1):
-                line = line.strip()
-                if not line:
-                    continue
-
-                try:
-                    row = json.loads(line)
-                except json.JSONDecodeError as e:
-                    print(f"[QuestionSupportBank] Bad JSON on line {line_number}: {e}")
-                    continue
-
-                question_id = str(row.get("question_id", "")).strip()
-                if not question_id:
-                    print(f"[QuestionSupportBank] Missing question_id on line {line_number}")
-                    continue
-
-                self._by_id[question_id] = row
+        self._by_text = {}
+
+        if self.data_path.exists():
+            with self.data_path.open("r", encoding="utf-8") as handle:
+                for raw_line in handle:
+                    line = raw_line.strip()
+                    if not line:
+                        continue
+                    try:
+                        item = json.loads(line)
+                    except json.JSONDecodeError:
+                        continue
+                    self._store_item(item)
 
         self._loaded = True
-        print(f"[QuestionSupportBank] Loaded {len(self._by_id)} support entries.")
 
-    def get(self, question_id: Optional[str]) -> Optional[Dict[str, Any]]:
+    def _ensure_loaded(self) -> None:
         if not self._loaded:
             self.load()
 
-        if not question_id:
-            return None
-
-        return self._by_id.get(str(question_id).strip())
-
-
-question_support_bank = QuestionSupportBank()
+    def _store_item(self, item: Dict[str, Any]) -> None:
+        if not isinstance(item, dict):
+            return
+        qid = str(item.get("question_id") or "").strip()
+        qtext = self._normalize(item.get("question_text") or item.get("stem") or "")
+        if qid:
+            self._by_id[qid] = item
+        if qtext:
+            self._by_text[qtext] = item
+
+    def get(self, question_id: Optional[str] = None, question_text: Optional[str] = None) -> Optional[Dict[str, Any]]:
+        self._ensure_loaded()
+        qid = str(question_id or "").strip()
+        if qid and qid in self._by_id:
+            return dict(self._by_id[qid])
+
+        qtext = self._normalize(question_text)
+        if qtext and qtext in self._by_text:
+            return dict(self._by_text[qtext])
+        return None
+
+    def upsert(self, item: Dict[str, Any]) -> None:
+        self._ensure_loaded()
+        self._store_item(item)
+
+    def all_items(self) -> List[Dict[str, Any]]:
+        self._ensure_loaded()
+        return [dict(v) for v in self._by_id.values()]
+
+
+question_support_bank = QuestionSupportBank()