Update handler.py

handler.py

@@ -1,20 +1,21 @@
 # -*- coding: utf-8 -*-
 """
-PULSE ECG Handler — Demo Parity + Style Hint + Robust Fallbacks + Debug + Dynamic Vision Size
-- Demo app.py ile aynı üretim ayarları:
+PULSE ECG Handler — Demo Parity + Style Hint + Robust Fallbacks + Debug + Dynamic Vision Size + JSON/Report (EN)
+- Generation settings aligned with demo app.py:
   do_sample=True, temperature=0.05, top_p=1.0, max_new_tokens=4096
-- Stopping: konuşma ayırıcıda (conv.sep/sep2) güvenli token-eşleşmeli kriter
-- Görsel tensörü: .half() ve model cihazında
-- Streamer: TextIteratorStreamer (demo gibi), thread ile generate
-- Seed/deterministic KAPALI (göndermezseniz); demo gibi stokastik
-- STYLE_HINT: demo üslubuna (narratif + sonda tek satır structured impression)
-- Post-process: yalnızca whitespace/biçim temizliği
-- Ekler:
-  * DEBUG yardımcıları (ENV: DEBUG=1)
-  * Dynamic vision size: vision tower -> processor + preprocess/fallback
+- Stopping: safe keyword match on conversation separator (conv.sep/sep2)
+- Image tensor: .half() on model device
+- Streamer: TextIteratorStreamer with background thread (demo-like)
+- Stochastic by default (seed/deterministic OFF unless provided)
+- STYLE_HINT: narrative + single-line 'Structured clinical impression:' ending
+- Post-process: whitespace cleanup only
+- Extras:
+  * DEBUG helpers (ENV: DEBUG=1)
+  * Dynamic vision size (vision tower -> processor + preprocess/fallback)
   * image_processor fallback (AutoProcessor → CLIPImageProcessor)
   * process_images fallback (torchvision + CLIP norm)
-  * FastAPI wrapper: /health, /info, /query, /debug
+  * FastAPI wrapper: /health, /info, /query, /debug, /analyze/json, /analyze/report-en
+  * JSON schema (EN) and report renderer (table text + narrative)
 """
 
 import os
@@ -66,7 +67,7 @@ except Exception as e:
     TRANSFORMERS_AVAILABLE = False
     warn(f"transformers not available: {e}")
 
-# ====== HF Hub logging (opsiyonel) ======
+# ====== HF Hub logging (optional) ======
 try:
     from huggingface_hub import HfApi, login
     HF_HUB_AVAILABLE = True
@@ -96,7 +97,7 @@ context_len = None
 args = None
 model_initialized = False
 
-# ====== Style Hint (demo benzeri üslup) ======
+# ====== Style Hint (demo-like narrative) ======
 STYLE_HINT = (
     "Write one concise narrative paragraph that covers rhythm, heart rate, cardiac axis, "
     "P waves and PR interval, QRS morphology and duration, ST segments, T waves, and QT/QTc. "
@@ -105,6 +106,30 @@ STYLE_HINT = (
     "followed by a succinct, comma-separated summary of the key diagnoses."
 )
 
+# ====== JSON Schema (EN) for strict machine-readable output ======
+JSON_SCHEMA_HINT_EN = """
+Return ONLY a valid JSON object that matches EXACTLY this schema:
+
+{
+  "heart_rate_bpm": int,                     // e.g., 128
+  "rhythm": "string",                        // e.g., "Sinus tachycardia"
+  "qrs_axis": "string",                      // e.g., "Normal (+16°)"
+  "p_waves": "string",                       // e.g., "Normal"
+  "pr_interval_ms": int,                     // e.g., 160
+  "qrs_duration_ms": int,                    // e.g., 84
+  "t_waves": "string",                       // e.g., "Negative in DIII, aVF, V1–V4"
+  "qtc_ms": int,                             // e.g., 467
+  "qtc_comment": "string",                   // e.g., "Mildly prolonged"
+  "additional_comments": "string"            // e.g., "S1Q3T3 pattern and anterior T-wave inversions present."
+}
+
+Rules:
+- Output MUST be valid JSON with no extra text before or after.
+- Units: use numbers for bpm and ms (integers only).
+- If unknown, use null (ints may be null).
+- Use standard cardiology terminology in English.
+"""
+
 # ===================== Utilities =====================
 def _safe_upload(path: str):
     if api and repo_name and path and os.path.isfile(path):
@@ -124,10 +149,10 @@ def _conv_log_path() -> str:
 
 def load_image_any(image_input: Union[str, dict]) -> Image.Image:
     """
-    Desteklenen:
+    Supported:
       - URL (http/https)
-      - yerel dosya yolu
-      - base64 (opsiyonel data URL prefix ile)
+      - local file path
+      - base64 (optionally with data URL prefix)
       - {"image": <base64|dataurl>}
     """
     if isinstance(image_input, str):
@@ -138,7 +163,7 @@ def load_image_any(image_input: Union[str, dict]) -> Image.Image:
             return Image.open(BytesIO(r.content)).convert("RGB")
         if os.path.exists(s):
             return Image.open(s).convert("RGB")
-        # base64 (dataurl olabilir)
+        # base64 (maybe dataurl)
         if s.startswith("data:image"):
             s = s.split(",", 1)[1]
         raw = base64.b64decode(s)
@@ -162,8 +187,7 @@ def _postprocess_min(text: str) -> str:
 # ====== Vision helpers (dynamic size) ======
 def get_vision_expected_size(m, default: int = 336) -> int:
     """
-    Modelin vision tower'ının beklediği input boyutunu döndürür (örn. 336).
-    LLaVA/CLIP konfiglerinde genelde `image_size` bulunur.
+    Returns expected image size for the model's vision tower (e.g., 336).
     """
     try:
         vt = m.get_vision_tower()
@@ -180,7 +204,7 @@ def get_vision_expected_size(m, default: int = 336) -> int:
     return default
 
 def force_processor_size(proc, size: int):
-    """Processor'ın resize/crop alanlarını güvenle hedef boyuta zorlar."""
+    """Force processor resize/crop to target size safely."""
     try:
         # size
         if hasattr(proc, "size"):
@@ -206,7 +230,7 @@ def force_processor_size(proc, size: int):
     except Exception as e:
         warn(f"[processor] force size failed: {e}")
 
-# ====== Güvenli Stop Kriteri (conv separator) ======
+# ====== Safe Stop Criteria (conv separator) ======
 class SafeKeywordsStoppingCriteria(StoppingCriteria):
     def __init__(self, keyword: str, tokenizer):
         self.tokenizer = tokenizer
@@ -241,7 +265,7 @@ class ChatSessionManager:
     def __init__(self):
         self.chatbot = None
         self.args = None
-               self.model_path = None
+        self.model_path = None
     def init_if_needed(self, args, model_path, tokenizer, model, image_processor, context_len):
         if self.chatbot is None:
             self.args = args
@@ -274,6 +298,7 @@ def generate_response(
     conv_mode_override: Optional[str] = None,
     repetition_penalty: Optional[float] = None,
     det_seed: Optional[int] = None,
+    output_mode: Optional[str] = "narrative",   # "narrative" | "json" | "report_en"
 ):
     if not (LLAVA_AVAILABLE and TRANSFORMERS_AVAILABLE):
         return {"error": "Required libraries not available (llava/transformers)"}
@@ -285,17 +310,54 @@ def generate_response(
     if max_new_tokens is None: max_new_tokens = 4096
     if repetition_penalty is None: repetition_penalty = 1.0
 
-    dbg(f"[gen] temperature={temperature} top_p={top_p} max_new_tokens={max_new_tokens} rep={repetition_penalty} seed={det_seed}")
+    dbg(f"[gen] temperature={temperature} top_p={top_p} max_new_tokens={max_new_tokens} rep={repetition_penalty} seed={det_seed} mode={output_mode}")
+
+    # For "report_en", compose by calling json + narrative branches
+    if output_mode == "report_en":
+        first = generate_response(
+            message_text=message_text,
+            image_input=image_input,
+            temperature=temperature, top_p=top_p,
+            max_new_tokens=max_new_tokens,
+            conv_mode_override=conv_mode_override,
+            repetition_penalty=repetition_penalty,
+            det_seed=det_seed,
+            output_mode="json",
+        )
+        if not isinstance(first, dict) or "response" not in first or not isinstance(first["response"], dict):
+            return first
+        data = first["response"]
+
+        second = generate_response(
+            message_text=message_text,
+            image_input=image_input,
+            temperature=temperature, top_p=top_p,
+            max_new_tokens=min(int(max_new_tokens), 512),
+            conv_mode_override=conv_mode_override,
+            repetition_penalty=repetition_penalty,
+            det_seed=det_seed,
+            output_mode="narrative",
+        )
+        narrative = second.get("response") if isinstance(second, dict) else None
+
+        table_txt = render_ecg_table_en(data)
+        return {
+            "status": "success",
+            "report": {"table_text": table_txt, "json": data, "narrative": narrative},
+            "conversation_id": id(chatbot)  # not conversation; narrative branch already logged
+        }
 
     chatbot = chat_manager.get_chatbot(args, args.model_path, tokenizer, model, image_processor, context_len)
     if conv_mode_override and conv_mode_override in conv_templates:
         chatbot.conversation = conv_templates[conv_mode_override].copy()
 
+    # Load image (PIL)
     try:
         pil_img = load_image_any(image_input)
     except Exception as e:
         return {"error": f"Failed to load image: {e}"}
 
+    # Save image log (optional)
     img_hash, img_path = "NA", None
     try:
         buf = BytesIO(); pil_img.save(buf, format="JPEG"); raw = buf.getvalue()
@@ -311,18 +373,16 @@ def generate_response(
     device = next(chatbot.model.parameters()).device
     dtype = torch.float16
 
-    # === Görüntü ön-işleme → tensör (dinamik boy) ===
+    # === Image preprocessing → tensor (dynamic size) ===
     expected_size = get_vision_expected_size(chatbot.model, default=336)
     dbg(f"[pre] dynamic expected_size={expected_size} | processor={type(chatbot.image_processor)}")
 
-    # 3.1) Processor.preprocess varsa kullan (en stabil yol)
     image_tensor = None
     try:
         if hasattr(chatbot.image_processor, "preprocess"):
             px = chatbot.image_processor.preprocess(pil_img, return_tensors="pt")
             image_tensor = px.get("pixel_values", px)
             if not isinstance(image_tensor, torch.Tensor):
-                # Bazı processor'lar nested dict döndürebilir
                 image_tensor = image_tensor["pixel_values"]
             if image_tensor.ndim == 3:
                 image_tensor = image_tensor.unsqueeze(0)
@@ -331,8 +391,7 @@ def generate_response(
         else:
             raise AttributeError("processor has no preprocess")
     except Exception as e_pre:
-        warn(f"[pre] processor.preprocess not used: {e_pre} → process_images denenecek…")
-        # 3.2) LLaVA'nın process_images yolu
+        warn(f"[pre] processor.preprocess not used: {e_pre} → process_images fallback…")
         try:
             processed = process_images([pil_img], chatbot.image_processor, chatbot.model.config)
             if isinstance(processed, (list, tuple)) and len(processed) > 0:
@@ -347,8 +406,7 @@ def generate_response(
             image_tensor = image_tensor.to(device=device, dtype=dtype)
             dbg(f"[pre] process_images ok → {tuple(image_tensor.shape)}")
         except Exception as e_proc:
-            warn(f"[pre] process_images failed: {e_proc} → manual CLIP fallback (dinamik size) kullanılacak.")
-            # 3.3) Manuel CLIP fallback (dinamik expected_size)
+            warn(f"[pre] process_images failed: {e_proc} → manual CLIP fallback (dynamic size).")
             from torchvision import transforms
             from torchvision.transforms import InterpolationMode
             preprocess = transforms.Compose([
@@ -366,8 +424,13 @@ def generate_response(
     if image_tensor is None:
         return {"error": "Image processing failed (no tensor produced)"}
 
-    msg = (message_text or "").strip()
-    msg = f"{msg}\n\n{STYLE_HINT}"
+    # ===== Build message according to output_mode =====
+    base_msg = (message_text or "").strip()
+    if output_mode == "json":
+        msg = f"{base_msg}\n\n{JSON_SCHEMA_HINT_EN}"
+    else:  # "narrative"
+        msg = f"{base_msg}\n\n{STYLE_HINT}"
+
     dbg(f"[prompt] conv_sep_style={chatbot.conversation.sep_style} sep_len={len(chatbot.conversation.sep)}")
     _, input_ids = _build_prompt_and_ids(chatbot, msg, device)
 
@@ -411,6 +474,7 @@ def generate_response(
     except Exception as e:
         return {"error": f"Generation failed: {e}"}
 
+    # Logging
     try:
         row = {
             "time": datetime.datetime.now().isoformat(),
@@ -426,6 +490,19 @@ def generate_response(
     except Exception as e:
         warn(f"[log] failed: {e}")
 
+    # If JSON mode, parse and return as object
+    if output_mode == "json":
+        try:
+            start = text.find("{"); end = text.rfind("}")
+            if start != -1 and end != -1 and end > start:
+                obj = json.loads(text[start:end+1])
+            else:
+                return {"error": "JSON block not found", "raw": text}
+        except Exception as e:
+            return {"error": f"JSON parse failed: {e}", "raw": text}
+        return {"status": "success", "response": obj, "conversation_id": id(chatbot.conversation)}
+
+    # Default narrative
     return {"status": "success", "response": text, "conversation_id": id(chatbot.conversation)}
 
 # ===================== Public API =====================
@@ -450,6 +527,8 @@ def query(payload: dict):
 
         conv_mode_override = payload.get("conv_mode", None)
         det_seed           = payload.get("det_seed", None)
+        output_mode        = payload.get("output_mode", "narrative")  # "narrative" | "json" | "report_en"
+
         if det_seed is not None:
             try: det_seed = int(det_seed)
             except Exception: det_seed = None
@@ -463,6 +542,7 @@ def query(payload: dict):
             conv_mode_override=conv_mode_override,
             repetition_penalty=repetition_penalty,
             det_seed=det_seed,
+            output_mode=output_mode,
         )
     except Exception as e:
         return {"error": f"Query failed: {e}"}
@@ -521,41 +601,41 @@ def initialize_model():
         model_.eval()
         dbg(f"[init] device={next(model_.parameters()).device}, cuda_available={torch.cuda.is_available()}")
 
-        # --- vision tower beklenen image_size'ı al ---
+        # Vision tower expected image size
         expected_size = get_vision_expected_size(model_, default=336)
         dbg(f"[init] vision expected image_size={expected_size}")
 
-        # --- image_processor fallback zinciri (model path > AutoProcessor > CLIP 224/336) ---
+        # image_processor fallback chain
         try:
             if image_processor_ is None:
-                dbg("[init] image_processor None → AutoProcessor(model_path) deneniyor…")
+                dbg("[init] image_processor None → AutoProcessor(model_path)…")
                 try:
                     from transformers import AutoProcessor
                     image_processor_ = AutoProcessor.from_pretrained(args.model_path)
-                    dbg("[init] image_processor: AutoProcessor.from_pretrained(model_path) yüklendi.")
+                    dbg("[init] image_processor: AutoProcessor.from_pretrained(model_path) loaded.")
                 except Exception as _e1:
                     dbg(f"[init] AutoProcessor(model_path) failed: {_e1}")
                     try:
                         from transformers import AutoProcessor
                         clip_id = "openai/clip-vit-large-patch14-336" if expected_size >= 336 else "openai/clip-vit-large-patch14"
                         image_processor_ = AutoProcessor.from_pretrained(clip_id)
-                        dbg(f"[init] AutoProcessor({clip_id}) yüklendi.")
+                        dbg(f"[init] AutoProcessor({clip_id}) loaded.")
                     except Exception as _e2:
                         from transformers import CLIPImageProcessor
                         clip_id = "openai/clip-vit-large-patch14-336" if expected_size >= 336 else "openai/clip-vit-large-patch14"
                         image_processor_ = CLIPImageProcessor.from_pretrained(clip_id)
-                        warn(f"[init] CLIPImageProcessor({clip_id}) fallback kullanılıyor.")
+                        warn(f"[init] CLIPImageProcessor({clip_id}) fallback in use.")
         except Exception as _e:
             warn(f"[init] image_processor fallback chain failed: {_e}")
 
-        # --- processor'ın boyutlarını vision tower'a uydur ---
+        # Force processor sizes to match tower
         try:
             if image_processor_ is not None:
                 force_processor_size(image_processor_, expected_size)
         except Exception as e_ip:
             warn(f"[init] processor size set error: {e_ip}")
 
-        # --- image_processor introspection ---
+        # Processor introspection
         try:
             ip = image_processor_
             if ip is not None:
@@ -563,7 +643,7 @@ def initialize_model():
                 size_sz = getattr(getattr(ip, "size", None), "shortest_edge", None) or getattr(ip, "size", None)
                 dbg(f"[init] image_processor crop_size={crop_sz} size={size_sz} class={ip.__class__.__name__}")
             else:
-                warn("[init] image_processor yine None (fallback da başarısız).")
+                warn("[init] image_processor still None (fallback failed).")
         except Exception as e_ip2:
             warn(f"[init] image_processor inspect error: {e_ip2}")
 
@@ -579,9 +659,45 @@ def initialize_model():
         warn(f"[init] failed: {e}")
         return False
 
+# ===================== Report rendering (EN) =====================
+def render_ecg_table_en(d: Dict[str, Any]) -> str:
+    def g(k, default="—"):
+        v = d.get(k, None)
+        if v is None: return default
+        return str(v)
+
+    hr = g("heart_rate_bpm")
+    rhythm = g("rhythm")
+    axis = g("qrs_axis")
+    p = g("p_waves")
+    pr = g("pr_interval_ms")
+    qrs_dur = g("qrs_duration_ms")
+    t = g("t_waves")
+    qtc = g("qtc_ms")
+    qtc_c = g("qtc_comment")
+    extra = g("additional_comments")
+
+    lines = [
+        "ECG ANALYSIS",
+        "────────────",
+        f"Heart rate        : {hr} beats/min",
+        f"Rhythm            : {rhythm}",
+        f"QRS axis          : {axis}",
+        f"P waves           : {p}",
+        f"PR interval       : {pr} ms",
+        f"QRS duration      : {qrs_dur} ms",
+        f"T waves           : {t}",
+        f"QTc               : {qtc_c} ({qtc} ms)",
+        "",
+        "Additional comments",
+        "──────────────────",
+        f"{extra}"
+    ]
+    return "\n".join(lines)
+
 # ===================== HF EndpointHandler =====================
 class EndpointHandler:
-    """Hugging Face Endpoint uyumlu sınıf"""
+    """Hugging Face Endpoint-compatible wrapper."""
     def __init__(self, model_dir):
         self.model_dir = model_dir
         print(f"EndpointHandler initialized with model_dir: {model_dir}")
@@ -595,7 +711,7 @@ class EndpointHandler:
         return get_model_info()
 
 if __name__ == "__main__":
-    print("Handler ready (Demo Parity + Style Hint + whitespace post-process + dynamic size + fallbacks + debug). Use `EndpointHandler` or `query`.")
+    print("Handler ready (Demo Parity + Style Hint + whitespace post-process + dynamic size + fallbacks + debug + JSON/Report-EN). Use `EndpointHandler` or `query`.")
 
 # ===================== Minimal FastAPI Wrapper =====================
 try:
@@ -607,7 +723,7 @@ except Exception as e:
     warn(f"fastapi/pydantic not available: {e}")
 
 if FASTAPI_AVAILABLE:
-    app = FastAPI(title="PULSE ECG Handler API", version="1.0.0")
+    app = FastAPI(title="PULSE ECG Handler API", version="1.1.0")
 
     class QueryIn(BaseModel):
         message: str | None = None
@@ -625,6 +741,7 @@ if FASTAPI_AVAILABLE:
         repetition_penalty: float | None = None
         conv_mode: str | None = None
         det_seed: int | None = None
+        output_mode: str | None = None  # "narrative" | "json" | "report_en"
 
     @app.on_event("startup")
     async def _startup():
@@ -677,5 +794,17 @@ if FASTAPI_AVAILABLE:
     @app.post("/query")
     async def _query(payload: QueryIn):
         return query({k: v for k, v in payload.dict().items() if v is not None})
+
+    @app.post("/analyze/json")
+    async def analyze_json(payload: QueryIn):
+        data = {k: v for k, v in payload.dict().items() if v is not None}
+        data["output_mode"] = "json"
+        return query(data)
+
+    @app.post("/analyze/report-en")
+    async def analyze_report_en(payload: QueryIn):
+        data = {k: v for k, v in payload.dict().items() if v is not None}
+        data["output_mode"] = "report_en"
+        return query(data)
 else:
-    app = None  # uvicorn handler:app çalıştırıldığında import error verir
+    app = None  # Running "uvicorn handler:app" will raise import error if FastAPI missing