Update handler.py

handler.py

@@ -1,73 +1,57 @@
 # -*- coding: utf-8 -*-
 """
-PULSE ECG Handler — Deterministic JSON → Table + Narrative (age+sex aware) with Robust Fallbacks
-
-Modes
-- output_mode="json"       → returns structured JSON (single model call)
-- output_mode="report_en"  → returns JSON + table + deterministic narrative (single model call)
-- output_mode="narrative"  → classic free-form model narrative (STYLE_HINT used)
-
-Highlights
-- Age group ("0-15" | "15-65" | "65+") and sex ("male" | "female") are accepted in payload and are
-  used only in deterministic narrative rendering (not sent to the model).
-- Robust JSON parsing:
-    1) direct JSON slice
-    2) cleanup pseudo-JSON (_coerce_pseudo_json)
-    3) regex-based field extraction from free text (_extract_fields_from_text)
-- Safe stop criteria, dynamic vision-size processor, logging hooks (optional HF Hub upload).
+PULSE ECG Handler — Demo Parity + Style Hint
+- Demo app.py ile aynı üretim ayarları:
+  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) yaklaşmak için
+- Post-process: YALNIZCA whitespace/biçim normalizasyonu (yönetim/öneri cümleleri korunur)
 """
 
 import os
 import re
 import json
 import base64
-import math
 import hashlib
 import datetime
 from io import BytesIO
 from threading import Thread
-from typing import Optional, Union, Any, Dict
+from typing import Optional, Union
 
 import torch
 from PIL import Image
 import requests
 
-# ========= Debug Helpers =========
-def _env_bool(name: str, default: bool = False) -> bool:
-    v = os.getenv(name)
-    if v is None:
-        return default
-    return str(v).strip().lower() in {"1", "true", "yes", "y", "on"}
-
-DEBUG = _env_bool("DEBUG", False)
-
-def dbg(*args, **kwargs):
-    if DEBUG:
-        print("[DEBUG]", *args, **kwargs)
-
-def warn(*args, **kwargs):
-    print("[WARN]", *args, **kwargs)
-
-# ========= LLaVA & Transformers =========
+# ====== LLaVA & Transformers ======
 try:
-    from llava.constants import IMAGE_TOKEN_INDEX, DEFAULT_IMAGE_TOKEN
+    from llava.constants import (
+        IMAGE_TOKEN_INDEX,
+        DEFAULT_IMAGE_TOKEN,
+    )
     from llava.conversation import conv_templates, SeparatorStyle
     from llava.model.builder import load_pretrained_model
-    from llava.mm_utils import tokenizer_image_token, process_images, get_model_name_from_path
+    from llava.mm_utils import (
+        tokenizer_image_token,
+        process_images,
+        get_model_name_from_path,
+    )
     from llava.utils import disable_torch_init
     LLAVA_AVAILABLE = True
 except Exception as e:
     LLAVA_AVAILABLE = False
-    warn(f"LLaVA not available: {e}")
+    print(f"[WARN] LLaVA not available: {e}")
 
 try:
     from transformers import TextIteratorStreamer, StoppingCriteria
     TRANSFORMERS_AVAILABLE = True
 except Exception as e:
     TRANSFORMERS_AVAILABLE = False
-    warn(f"transformers not available: {e}")
+    print(f"[WARN] transformers not available: {e}")
 
-# ========= (Optional) HF Hub logging =========
+# ====== HF Hub logging (opsiyonel) ======
 try:
     from huggingface_hub import HfApi, login
     HF_HUB_AVAILABLE = True
@@ -82,13 +66,14 @@ if HF_HUB_AVAILABLE and "HF_TOKEN" in os.environ:
         api = HfApi()
         repo_name = os.environ.get("LOG_REPO", "")
     except Exception as e:
-        warn(f"[HF Hub] init failed: {e}")
-        api, repo_name = None, ""
+        print(f"[HF Hub] init failed: {e}")
+        api = None
+        repo_name = ""
 
 LOGDIR = "./logs"
 os.makedirs(LOGDIR, exist_ok=True)
 
-# ========= Global State =========
+# ====== Global State ======
 tokenizer = None
 model = None
 image_processor = None
@@ -96,7 +81,7 @@ context_len = None
 args = None
 model_initialized = False
 
-# ========= Prompts =========
+# ====== Style Hint (demo benzeri üslup) ======
 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,26 +90,8 @@ STYLE_HINT = (
     "followed by a succinct, comma-separated summary of the key diagnoses."
 )
 
-# Example-only schema (no type hints). The model copies this structure.
-JSON_SCHEMA_HINT_EN = """
-Return ONLY a valid JSON object. Do not include comments, types, or extra text.
-If a value is unknown, use null (for numbers) or "" (for strings).
-
-{
-  "heart_rate_bpm": 100,
-  "rhythm": "Sinus rhythm",
-  "qrs_axis": "Normal",
-  "p_waves": "Normal",
-  "pr_interval_ms": 160,
-  "qrs_duration_ms": 90,
-  "t_waves": "Normal",
-  "qtc_ms": 420,
-  "qtc_comment": "Normal",
-  "additional_comments": ""
-}
-"""
+# ===================== Utilities =====================
 
-# ========= Utilities =========
 def _safe_upload(path: str):
     if api and repo_name and path and os.path.isfile(path):
         try:
@@ -135,7 +102,7 @@ def _safe_upload(path: str):
                 repo_type="dataset",
             )
         except Exception as e:
-            warn(f"[upload] failed for {path}: {e}")
+            print(f"[upload] failed for {path}: {e}")
 
 def _conv_log_path() -> str:
     t = datetime.datetime.now()
@@ -143,7 +110,11 @@ def _conv_log_path() -> str:
 
 def load_image_any(image_input: Union[str, dict]) -> Image.Image:
     """
-    Supports: http(s) URL, local path, base64 (with or without data URL prefix), or {"image": <...>}
+    Desteklenen:
+      - URL (http/https)
+      - yerel dosya yolu
+      - base64 (opsiyonel data URL prefix ile)
+      - {"image": <base64|dataurl>}
     """
     if isinstance(image_input, str):
         s = image_input.strip()
@@ -153,15 +124,24 @@ 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)
         if s.startswith("data:image"):
             s = s.split(",", 1)[1]
         raw = base64.b64decode(s)
         return Image.open(BytesIO(raw)).convert("RGB")
+
     if isinstance(image_input, dict) and "image" in image_input:
         return load_image_any(image_input["image"])
+
     raise ValueError("Unsupported image input format")
 
 def _normalize_whitespace(text: str) -> str:
+    """
+    Gereksiz boşluk/boş satırları toparlar:
+    - Satır başı/sonu boşluklarını siler
+    - Birden çok boşluğu tek boşluğa indirger
+    - 3+ boş satırı 1 boş satıra indirger
+    """
     text = text.replace("\r\n", "\n").replace("\r", "\n")
     lines = [re.sub(r"[ \t]+", " ", ln.strip()) for ln in text.split("\n")]
     text = "\n".join(lines).strip()
@@ -169,168 +149,32 @@ def _normalize_whitespace(text: str) -> str:
     return text
 
 def _postprocess_min(text: str) -> str:
+    # Yalnızca whitespace/biçim temizliği
     return _normalize_whitespace(text)
 
-def _coerce_pseudo_json(text: str) -> str:
-    """
-    Coerce pseudo-JSON (e.g., 'int | none', 'none', Python booleans) into valid JSON string.
-    """
-    if not isinstance(text, str):
-        return ""
-    s = text
-
-    # Keep only the outermost JSON object if stray tokens are around
-    i, j = s.find("{"), s.rfind("}")
-    if i != -1 and j != -1 and j > i:
-        s = s[i:j+1]
-
-    # Remove type-like hints → replace with valid JSON placeholders
-    s = re.sub(r':\s*int\s*\|\s*none', ': null', s, flags=re.I)
-    s = re.sub(r':\s*string\s*\|\s*none', ': ""', s, flags=re.I)
-
-    # Python/other tokens → JSON
-    s = re.sub(r'\bNone\b|\bnone\b', 'null', s, flags=re.I)
-    s = re.sub(r'\bTrue\b', 'true', s)
-    s = re.sub(r'\bFalse\b', 'false', s)
-
-    # Strip inline comments
-    s = re.sub(r'//.*', '', s)   # JS style
-    s = re.sub(r'#.*', '', s)    # Python style
-
-    # Collapse repeated commas
-    s = re.sub(r',\s*,+', ',', s)
-
-    return s.strip()
-
-def _to_int_or_none(x: Optional[str]) -> Optional[int]:
-    if x is None:
-        return None
-    x = x.strip()
-    if not x:
-        return None
-    try:
-        v = int(float(x))
-        if math.isnan(v):
-            return None
-        return v
-    except Exception:
-        return None
-
-def _extract_fields_from_text(text: str) -> Dict[str, Any]:
-    """
-    Extract fields from free text when model failed to return valid JSON.
-    Missing numeric fields -> None; missing text -> "".
-    """
-    if not isinstance(text, str):
-        text = str(text or "")
-
-    def rex(pattern, flags=re.I):
-        m = re.search(pattern, text, flags)
-        return m.group(1).strip() if m else None
-
-    # bpm
-    hr = rex(r"(?:heart\s*rate|hr)\s*[:=]?\s*(\d{1,3})\s*(?:bpm|beats?/min)?")
-    if hr is None:
-        hr = rex(r"\b(\d{2,3})\s*(?:bpm|beats?/min)\b")
-
-    # PR/QRS/QTc ms
-    pr  = rex(r"\bPR\s*(?:interval)?\s*[:=]?\s*(\d{2,4})\s*ms\b")
-    qrs = rex(r"\bQRS\s*(?:duration)?\s*[:=]?\s*(\d{2,4})\s*ms\b")
-    qtc = rex(r"\bQTc?\s*[:=]?\s*(\d{2,4})\s*ms\b")
-
-    # Axis
-    axis = rex(r"\bQRS\s*axis\s*[:=]?\s*([+\-]?\d+°|normal|left|right|indeterminate)\b")
-
-    # Rhythm
-    rhythm = rex(r"\brhythm\s*[:=]?\s*([A-Za-z \-]+)")
-    if rhythm is None:
-        rhythm = rex(r"\b(sinus\s+(?:tachycardia|bradycardia|rhythm)|atrial fibrillation|afib|atrial flutter|junctional rhythm)\b")
-
-    # P / T waves
-    p_waves = rex(r"\bP\s*waves?\s*[:=]?\s*([A-Za-z0-9, \-]+)")
-    t_waves = rex(r"\bT\s*waves?\s*[:=]?\s*([A-Za-z0-9, \-]+)")
-
-    # QTc comment
-    qtc_comment = rex(r"\bQTc\s*(?:comment|status)?\s*[:=]?\s*([A-Za-z \-]+)")
-
-    # Additional
-    additional = rex(r"(?:Additional\s*comments|Notes?)\s*[:\-]?\s*([\s\S]{0,300})")
-    if not additional:
-        additional = rex(r"\b(ST[- ](?:elevation|depression)|S1Q3T3|early repolarization|strain pattern)\b(?:[^\n\r]{0,120})")
-
-    return {
-        "heart_rate_bpm": _to_int_or_none(hr),
-        "rhythm": (rhythm or "").strip(),
-        "qrs_axis": (axis or "").strip(),
-        "p_waves": (p_waves or "").strip(),
-        "pr_interval_ms": _to_int_or_none(pr),
-        "qrs_duration_ms": _to_int_or_none(qrs),
-        "t_waves": (t_waves or "").strip(),
-        "qtc_ms": _to_int_or_none(qtc),
-        "qtc_comment": (qtc_comment or "").strip(),
-        "additional_comments": (additional or "").strip(),
-    }
-
-# ========= Vision helpers =========
-def get_vision_expected_size(m, default: int = 336) -> int:
+# ====== Güvenli Stop Kriteri (conv separator) ======
+class SafeKeywordsStoppingCriteria(StoppingCriteria):
     """
-    Return expected image size for the model vision tower if available.
+    conv.sep/sep2 bazlı token eşleşmesi; tensör → bool hatası yok.
     """
-    try:
-        vt = m.get_vision_tower()
-        vt_cfg = getattr(getattr(vt, "vision_tower", vt), "config", None)
-        if vt_cfg is None:
-            return default
-        if getattr(vt_cfg, "image_size", None):
-            return int(vt_cfg.image_size)
-        vc = getattr(vt_cfg, "vision_config", None)
-        if vc and getattr(vc, "image_size", None):
-            return int(vc.image_size)
-    except Exception as e:
-        dbg(f"[get_vision_expected_size] fallback default={default} because: {e}")
-    return default
-
-def force_processor_size(proc, size: int):
-    """Force processor resize/crop to target size safely."""
-    try:
-        if hasattr(proc, "size"):
-            if isinstance(proc.size, dict):
-                proc.size["shortest_edge"] = size
-            else:
-                try:
-                    proc.size.shortest_edge = size  # type: ignore[attr-defined]
-                except Exception:
-                    proc.size = {"shortest_edge": size}
-        if hasattr(proc, "crop_size"):
-            if isinstance(proc.crop_size, dict):
-                proc.crop_size["height"] = size
-                proc.crop_size["width"]  = size
-            else:
-                try:
-                    proc.crop_size.height = size  # type: ignore[attr-defined]
-                    proc.crop_size.width  = size  # type: ignore[attr-defined]
-                except Exception:
-                    proc.crop_size = {"height": size, "width": size}
-        dbg(f"[processor] forced size={size}")
-    except Exception as e:
-        warn(f"[processor] force size failed: {e}")
-
-# ========= Safe Stopper =========
-class SafeKeywordsStoppingCriteria(StoppingCriteria):
     def __init__(self, keyword: str, tokenizer):
+        self.tokenizer = tokenizer
         tok = tokenizer(keyword, add_special_tokens=False, return_tensors="pt").input_ids[0]
-        self.kw_ids = tok
+        self.kw_ids = tok  # shape: (n,)
+
     def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor, **kwargs) -> bool:
         if input_ids is None or input_ids.shape[0] == 0:
             return False
-        out = input_ids[0]
+        out = input_ids[0]  # assume bsz=1
         n = self.kw_ids.shape[0]
         if out.shape[0] < n:
             return False
         tail = out[-n:]
-        return torch.equal(tail, self.kw_ids.to(tail.device))
+        kw = self.kw_ids.to(tail.device)
+        return torch.equal(tail, kw)
+
+# ===================== Core Generation =====================
 
-# ========= Core Session =========
 class InferenceDemo:
     def __init__(self, args, model_path, tokenizer_, model_, image_processor_, context_len_):
         if not LLAVA_AVAILABLE:
@@ -339,6 +183,7 @@ class InferenceDemo:
         self.tokenizer, self.model, self.image_processor, self.context_len = (
             tokenizer_, model_, image_processor_, context_len_
         )
+        # Parite için sabit şablon
         self.conv_mode = "llava_v1"
         self.conversation = conv_templates[self.conv_mode].copy()
         self.num_frames = getattr(args, "num_frames", 16)
@@ -355,163 +200,24 @@ class ChatSessionManager:
             self.chatbot = InferenceDemo(args, model_path, tokenizer, model, image_processor, context_len)
     def get_chatbot(self, args, model_path, tokenizer, model, image_processor, context_len):
         self.init_if_needed(args, model_path, tokenizer, model, image_processor, context_len)
+        # Her çağrıda taze template (demo gibi yeni tur)
         self.chatbot.conversation = conv_templates[self.chatbot.conv_mode].copy()
         return self.chatbot
 
 chat_manager = ChatSessionManager()
 
 def _build_prompt_and_ids(chatbot, user_text: str, device: torch.device):
+    # DEMO PARİTE: sarım yok, tek görüntü için tek image token
     inp = f"{DEFAULT_IMAGE_TOKEN}\n{user_text}"
     chatbot.conversation.append_message(chatbot.conversation.roles[0], inp)
     chatbot.conversation.append_message(chatbot.conversation.roles[1], None)
     prompt = chatbot.conversation.get_prompt()
+
     input_ids = tokenizer_image_token(
         prompt, chatbot.tokenizer, IMAGE_TOKEN_INDEX, return_tensors="pt"
     ).unsqueeze(0).to(device)
     return prompt, input_ids
 
-# ========= Deterministic Renderers =========
-def render_ecg_table_en(d: Dict[str, Any]) -> str:
-    lines = ["ECG ANALYSIS", "────────────"]
-    if d.get("heart_rate_bpm") is not None:
-        lines.append(f"Heart rate        : {d['heart_rate_bpm']} beats/min")
-    if "rhythm" in d:
-        lines.append(f"Rhythm            : {d['rhythm']}")
-    if "qrs_axis" in d:
-        lines.append(f"QRS axis          : {d['qrs_axis']}")
-    if "p_waves" in d:
-        lines.append(f"P waves           : {d['p_waves']}")
-    if d.get("pr_interval_ms") is not None:
-        lines.append(f"PR interval       : {d['pr_interval_ms']} ms")
-    if d.get("qrs_duration_ms") is not None:
-        lines.append(f"QRS duration      : {d['qrs_duration_ms']} ms")
-    if "t_waves" in d:
-        lines.append(f"T waves           : {d['t_waves']}")
-    if d.get("qtc_ms") is not None:
-        qtc_c = (d.get("qtc_comment") or "").strip() or "—"
-        lines.append(f"QTc               : {qtc_c} ({d['qtc_ms']} ms)")
-    lines += ["", "Additional comments", "──────────────────", (d.get("additional_comments") or "").strip()]
-    return "\n".join(lines)
-
-def render_ecg_narrative_en(d: Dict[str, Any]) -> str:
-    """Deterministic narrative based on JSON + age_group + sex with 'Structured clinical impression' at the end."""
-    hr = d.get("heart_rate_bpm")
-    rhythm = d.get("rhythm")
-    axis = d.get("qrs_axis")
-    p = d.get("p_waves")
-    pr = d.get("pr_interval_ms")
-    qrs_dur = d.get("qrs_duration_ms")
-    t = d.get("t_waves")
-    qtc = d.get("qtc_ms")
-    extra = d.get("additional_comments")
-    age_group = d.get("patient_age_group")  # "0-15" | "15-65" | "65+"
-    sex = d.get("patient_sex")              # "male" | "female"
-
-    # thresholds by age group
-    if age_group == "0-15":
-        hr_low, hr_high = 70, 120
-        pr_low, pr_high = 110, 180
-        qrs_limit = 100
-        qtc_male, qtc_female = 460, 470
-    elif age_group == "65+":
-        hr_low, hr_high = 50, 100
-        pr_low, pr_high = 120, 220
-        qrs_limit = 120
-        qtc_male, qtc_female = 460, 480
-    else:  # default 15-65
-        hr_low, hr_high = 60, 100
-        pr_low, pr_high = 120, 200
-        qrs_limit = 120
-        qtc_male, qtc_female = 450, 470
-
-    para = []
-    # patient context
-    if age_group and sex:
-        para.append(f"The patient is a {age_group} years {sex}.")
-    elif age_group:
-        para.append(f"The patient belongs to the {age_group} years age group.")
-    elif sex:
-        para.append(f"The patient is {sex}.")
-
-    # Rhythm with age-adjusted normalization for sinus tachycardia
-    if rhythm:
-        if rhythm.lower() == "sinus tachycardia" and isinstance(hr, int) and hr_low <= hr <= hr_high:
-            para.append(
-                f"The electrocardiogram shows sinus rhythm, normal for age. "
-                f"Although labelled as sinus tachycardia, the heart rate of {hr} bpm is within the normal range for this age group."
-            )
-        else:
-            para.append(f"The electrocardiogram shows {rhythm.lower()}.")
-
-    # Heart rate comment
-    if isinstance(hr, int):
-        if hr < hr_low:
-            hr_comment = "bradycardia"
-        elif hr > hr_high:
-            hr_comment = "tachycardia"
-        else:
-            hr_comment = "within normal range"
-        para.append(f"The heart rate is {hr} bpm ({hr_comment}).")
-
-    # Axis / P / PR / QRS / T / QTc
-    if axis:
-        para.append(f"The QRS axis is {axis.lower()}.")
-    if p:
-        para.append(f"P waves are {p.lower()}.")
-    if isinstance(pr, int):
-        if pr < pr_low:
-            pr_comment = "short PR interval"
-        elif pr > pr_high:
-            pr_comment = "prolonged PR interval"
-        else:
-            pr_comment = "within normal range"
-        para.append(f"PR interval is {pr} ms ({pr_comment}).")
-    if isinstance(qrs_dur, int):
-        qrs_comment = "normal QRS duration" if qrs_dur < qrs_limit else "prolonged QRS (possible conduction delay)"
-        para.append(f"QRS duration is {qrs_dur} ms ({qrs_comment}).")
-    if t:
-        para.append(f"T waves: {t}.")
-    if isinstance(qtc, int):
-        if sex == "male":
-            if qtc > qtc_male:
-                qtc_comment = "prolonged for male"
-            elif qtc < 350:
-                qtc_comment = "shortened"
-            else:
-                qtc_comment = "normal for male"
-        elif sex == "female":
-            if qtc > qtc_female:
-                qtc_comment = "prolonged for female"
-            elif qtc < 360:
-                qtc_comment = "shortened"
-            else:
-                qtc_comment = "normal for female"
-        else:
-            if qtc > max(qtc_male, qtc_female):
-                qtc_comment = "prolonged"
-            elif qtc < 350:
-                qtc_comment = "shortened"
-            else:
-                qtc_comment = "normal"
-        para.append(f"QTc is {qtc} ms ({qtc_comment}).")
-
-    if isinstance(extra, str) and extra.strip():
-        para.append(extra.strip())
-
-    paragraph = " ".join(para).strip()
-
-    # Structured clinical impression (deterministic summary)
-    sci_bits = []
-    if rhythm: sci_bits.append(rhythm)
-    if axis: sci_bits.append(f"QRS axis: {axis}")
-    if isinstance(pr, int): sci_bits.append(f"PR {pr} ms")
-    if isinstance(qrs_dur, int): sci_bits.append(f"QRS {qrs_dur} ms")
-    if isinstance(qtc, int): sci_bits.append(f"QTc {qtc} ms")
-    if isinstance(extra, str) and extra.strip(): sci_bits.append(extra.strip())
-
-    return paragraph + "\n\n" + "Structured clinical impression: " + ", ".join(sci_bits)
-
-# ========= Generation =========
 def generate_response(
     message_text: str,
     image_input,
@@ -521,98 +227,72 @@ def generate_response(
     max_new_tokens: Optional[int] = None,
     conv_mode_override: Optional[str] = None,
     repetition_penalty: Optional[float] = None,
-    det_seed: Optional[int] = None,
-    output_mode: str = "narrative",  # "narrative" | "json" | "report_en"
-    patient_age_group: Optional[str] = None,
-    patient_sex: Optional[str] = None,
+    det_seed: Optional[int] = None,  # None → stokastik (demo gibi)
 ):
     if not (LLAVA_AVAILABLE and TRANSFORMERS_AVAILABLE):
         return {"error": "Required libraries not available (llava/transformers)"}
     if not message_text or image_input is None:
         return {"error": "Both 'message' and 'image' are required"}
 
+    # Varsayılanlar → demo
     if temperature is None: temperature = 0.05
     if top_p is None: top_p = 1.0
     if max_new_tokens is None: max_new_tokens = 4096
-    if repetition_penalty is None: repetition_penalty = 1.0
-
-    # Deterministic settings for schema modes
-    if output_mode in ("json", "report_en"):
-        temperature = 0.0
-        top_p = 1.0
-        repetition_penalty = 1.0
-        max_new_tokens = min(int(max_new_tokens), 1024)
-
-    dbg(f"[gen] temp={temperature} top_p={top_p} max_new={max_new_tokens} rep={repetition_penalty} mode={output_mode}")
+    if repetition_penalty is None: repetition_penalty = 1.0  # etkisiz
 
+    # Chat session
     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 → tensor
+    # Görüntü yükle
     try:
         pil_img = load_image_any(image_input)
     except Exception as e:
         return {"error": f"Failed to load image: {e}"}
 
+    # Log için hash+path
+    img_hash, img_path = "NA", None
+    try:
+        buf = BytesIO(); pil_img.save(buf, format="JPEG"); raw = buf.getvalue()
+        img_hash = hashlib.md5(raw).hexdigest()
+        t = datetime.datetime.now()
+        img_path = os.path.join(LOGDIR, "serve_images", f"{t.year:04d}-{t.month:02d}-{t.day:02d}", f"{img_hash}.jpg")
+        os.makedirs(os.path.dirname(img_path), exist_ok=True)
+        if not os.path.isfile(img_path):
+            pil_img.save(img_path)
+    except Exception as e:
+        print(f"[log] save image failed: {e}")
+
+    # Cihaz/dtype
     device = next(chatbot.model.parameters()).device
-    dtype = torch.float16
+    dtype = torch.float16  # demo: half
 
-    image_tensor = None
+    # Görüntü ön-işleme → tensör
     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):
-                image_tensor = image_tensor["pixel_values"]
-            if image_tensor.ndim == 3:
-                image_tensor = image_tensor.unsqueeze(0)
-            image_tensor = image_tensor.to(device=device, dtype=dtype)
+        processed = process_images([pil_img], chatbot.image_processor, chatbot.model.config)
+        if isinstance(processed, (list, tuple)) and len(processed) > 0:
+            image_tensor = processed[0]
+        elif isinstance(processed, torch.Tensor):
+            image_tensor = processed[0] if processed.ndim == 4 else processed
         else:
-            raise AttributeError("processor has no preprocess")
-    except Exception:
-        try:
-            processed = process_images([pil_img], chatbot.image_processor, chatbot.model.config)
-            if isinstance(processed, (list, tuple)) and len(processed) > 0:
-                image_tensor = processed[0]
-            elif isinstance(processed, torch.Tensor):
-                image_tensor = processed[0] if processed.ndim == 4 else processed
-            else:
-                raise ValueError("process_images returned empty")
-            if image_tensor.ndim == 3:
-                image_tensor = image_tensor.unsqueeze(0)
-            image_tensor = image_tensor.to(device=device, dtype=dtype)
-        except Exception:
-            from torchvision import transforms
-            from torchvision.transforms import InterpolationMode
-            expected_size = get_vision_expected_size(chatbot.model, default=336)
-            preprocess = transforms.Compose([
-                transforms.Resize(expected_size, interpolation=InterpolationMode.BICUBIC),
-                transforms.CenterCrop(expected_size),
-                transforms.ToTensor(),
-                transforms.Normalize(
-                    mean=[0.48145466, 0.4578275, 0.40821073],
-                    std=[0.26862954, 0.26130258, 0.27577711]
-                ),
-            ])
-            image_tensor = preprocess(pil_img).unsqueeze(0).to(device=device, dtype=dtype)
-
-    if image_tensor is None:
-        return {"error": "Image processing failed (no tensor produced)"}
-
-    # Build prompt
-    base_msg = (message_text or "").strip()
-    if output_mode in ("json", "report_en"):
-        msg = f"{base_msg}\n\n{JSON_SCHEMA_HINT_EN}"
-    else:  # "narrative"
-        msg = f"{base_msg}\n\n{STYLE_HINT}"
-
-    dbg(f"[prompt] mode={output_mode}")
+            return {"error": "Image processing returned empty"}
+        if image_tensor.ndim == 3:
+            image_tensor = image_tensor.unsqueeze(0)  # (1,C,H,W)
+        image_tensor = image_tensor.to(device=device, dtype=dtype)  # demo: half + device
+    except Exception as e:
+        return {"error": f"Image processing failed: {e}"}
+
+    # STYLE_HINT ekle ve prompt hazırla
+    msg = (message_text or "").strip()
+    msg = f"{msg}\n\n{STYLE_HINT}"
     _, input_ids = _build_prompt_and_ids(chatbot, msg, device)
 
+    # Stop string (conv separator) → güvenli kriter
     stop_str = chatbot.conversation.sep if chatbot.conversation.sep_style != SeparatorStyle.TWO else chatbot.conversation.sep2
     stopping = SafeKeywordsStoppingCriteria(stop_str, chatbot.tokenizer)
 
+    # Seed (gönderilmediyse stokastik → demo gibi)
     if det_seed is not None:
         try:
             s = int(det_seed)
@@ -623,76 +303,60 @@ def generate_response(
         except Exception:
             pass
 
-    # Generate with streamer
-    streamer = TextIteratorStreamer(chatbot.tokenizer, skip_prompt=True, skip_special_tokens=True)
+    # Streamer (demo gibi)
+    streamer = TextIteratorStreamer(
+        chatbot.tokenizer, skip_prompt=True, skip_special_tokens=True
+    )
+
+    # Generate kwargs — demo ayarları
     gen_kwargs = dict(
         inputs=input_ids,
         images=image_tensor,
         streamer=streamer,
-        do_sample=(temperature > 0.0),
-        temperature=float(temperature),
-        top_p=float(top_p),
-        max_new_tokens=int(max_new_tokens),
-        repetition_penalty=float(repetition_penalty),
+        do_sample=True,                     # DEMO
+        temperature=float(temperature),     # DEMO default 0.05
+        top_p=float(top_p),                 # DEMO default 1.0
+        max_new_tokens=int(max_new_tokens), # DEMO slider
+        repetition_penalty=float(repetition_penalty),  # default 1.0 → etkisiz
         use_cache=False,
-        stopping_criteria=[stopping],
+        stopping_criteria=[stopping],       # DEMO-benzeri durdurma
     )
 
+    # Üretim (arka thread) + akışı topla
     try:
         t = Thread(target=chatbot.model.generate, kwargs=gen_kwargs)
         t.start()
         chunks = []
         for piece in streamer:
             chunks.append(piece)
-        text = _postprocess_min("".join(chunks))
+        text = "".join(chunks)
+        text = _postprocess_min(text)   # yalnızca whitespace/format temizliği
         chatbot.conversation.messages[-1][-1] = text
     except Exception as e:
         return {"error": f"Generation failed: {e}"}
 
-    # output_mode handlers
-    if output_mode == "narrative":
-        return {"status": "success", "response": text, "conversation_id": id(chatbot.conversation)}
-
-    # For json & report_en → parse once, with robust fallbacks
+    # Log
     try:
-        start = text.find("{"); end = text.rfind("}")
-        if start == -1 or end == -1 or end <= start:
-            raise ValueError("JSON braces not found")
-        data = json.loads(text[start:end+1])
-        data["_parse_mode"] = "direct"
-    except Exception:
-        cleaned = _coerce_pseudo_json(text)
-        try:
-            data = json.loads(cleaned)
-            data["_parse_mode"] = "cleaned"
-        except Exception:
-            # Last resort: extract with regex from free text
-            data = _extract_fields_from_text(text)
-            data["_parse_mode"] = "extracted"
-
-    # Inject patient meta (local only)
-    if patient_age_group:
-        data["patient_age_group"] = patient_age_group
-    if patient_sex:
-        data["patient_sex"] = patient_sex
-
-    if output_mode == "json":
-        return {"status": "success", "response": data, "conversation_id": id(chatbot.conversation)}
-
-    if output_mode == "report_en":
-        narrative = render_ecg_narrative_en(data)
-        table_txt = render_ecg_table_en(data)
-        return {
-            "status": "success",
-            "report": {"table_text": table_txt, "json": data, "narrative": narrative},
-            "conversation_id": id(chatbot.conversation)
+        row = {
+            "time": datetime.datetime.now().isoformat(),
+            "type": "chat",
+            "model": "PULSE-7B",
+            "state": [(message_text, text)],
+            "image_hash": img_hash,
+            "image_path": img_path or "",
         }
+        with open(_conv_log_path(), "a", encoding="utf-8") as f:
+            f.write(json.dumps(row, ensure_ascii=False) + "\n")
+        _safe_upload(_conv_log_path()); _safe_upload(img_path or "")
+    except Exception as e:
+        print(f"[log] failed: {e}")
 
-    # Fallback
     return {"status": "success", "response": text, "conversation_id": id(chatbot.conversation)}
 
-# ========= Public API =========
+# ===================== Public API =====================
+
 def query(payload: dict):
+    """HF Endpoint entry (demo-like)."""
     global model_initialized, tokenizer, model, image_processor, context_len, args
     if not model_initialized:
         if not initialize_model():
@@ -705,19 +369,14 @@ def query(payload: dict):
         if not message.strip(): return {"error": "Missing 'message' text"}
         if image is None:       return {"error": "Missing 'image'. Use 'image', 'image_url', or 'img'."}
 
+        # Demo varsayılanları — payload override edebilir
         temperature        = float(payload.get("temperature", 0.05))
         top_p              = float(payload.get("top_p", 1.0))
         max_new_tokens     = int(payload.get("max_output_tokens", payload.get("max_new_tokens", payload.get("max_tokens", 4096))))
-        repetition_penalty = float(payload.get("repetition_penalty", 1.0))
+        repetition_penalty = float(payload.get("repetition_penalty", 1.0))  # etkisiz default
 
         conv_mode_override = payload.get("conv_mode", None)
         det_seed           = payload.get("det_seed", None)
-        output_mode        = payload.get("output_mode", "narrative")
-
-        # Optional patient meta (local use only)
-        patient_age_group  = payload.get("patient_age_group")
-        patient_sex        = payload.get("patient_sex")
-
         if det_seed is not None:
             try: det_seed = int(det_seed)
             except Exception: det_seed = None
@@ -731,9 +390,6 @@ def query(payload: dict):
             conv_mode_override=conv_mode_override,
             repetition_penalty=repetition_penalty,
             det_seed=det_seed,
-            output_mode=output_mode,
-            patient_age_group=patient_age_group,
-            patient_sex=patient_sex,
         )
     except Exception as e:
         return {"error": f"Query failed: {e}"}
@@ -756,13 +412,14 @@ def get_model_info():
         "device": str(next(model.parameters()).device) if model else "Unknown",
     }
 
-# ========= Init & Session =========
+# ===================== Init & Session =====================
+
 class _Args:
     def __init__(self):
         self.model_path = os.getenv("HF_MODEL_ID", "PULSE-ECG/PULSE-7B")
         self.model_base = None
         self.num_gpus   = int(os.getenv("NUM_GPUS", "1"))
-        self.conv_mode  = "llava_v1"
+        self.conv_mode  = "llava_v1"  # Parite için sabit
         self.max_new_tokens = int(os.getenv("MAX_NEW_TOKENS", "4096"))
         self.num_frames = 16
         self.load_8bit  = bool(int(os.getenv("LOAD_8BIT", "0")))
@@ -772,40 +429,22 @@ class _Args:
 def initialize_model():
     global tokenizer, model, image_processor, context_len, args
     if not LLAVA_AVAILABLE:
-        warn("[init] LLaVA not available; cannot init.")
+        print("[init] LLaVA not available; cannot init.")
         return False
     try:
         args = _Args()
-        dbg(f"[init] HF_MODEL_ID={args.model_path} | LOAD_8BIT={args.load_8bit} | LOAD_4BIT={args.load_4bit}")
         model_name = get_model_name_from_path(args.model_path)
-
         tokenizer_, model_, image_processor_, context_len_ = load_pretrained_model(
             args.model_path, args.model_base, model_name, args.load_8bit, args.load_4bit
         )
-        dbg(f"[init] loaded model/tokenizer/processor | context_len={context_len_}")
-
+        # demo: model'ı genelde cuda’da çalıştırır
         try:
             _ = next(model_.parameters()).device
         except Exception:
             if torch.cuda.is_available():
                 model_ = model_.to(torch.device("cuda"))
         model_.eval()
-        dbg(f"[init] device={next(model_.parameters()).device}, cuda={torch.cuda.is_available()}")
 
-        expected_size = get_vision_expected_size(model_, default=336)
-        try:
-            if image_processor_ is None:
-                from transformers import AutoProcessor, CLIPImageProcessor
-                try:
-                    image_processor_ = AutoProcessor.from_pretrained(args.model_path)
-                except Exception:
-                    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)
-            force_processor_size(image_processor_, expected_size)
-        except Exception as e_ip:
-            warn(f"[init] image_processor fallback/size set failed: {e_ip}")
-
-        # publish
         globals()["tokenizer"] = tokenizer_
         globals()["model"] = model_
         globals()["image_processor"] = image_processor_
@@ -815,12 +454,13 @@ def initialize_model():
         print("[init] model/tokenizer/image_processor loaded.")
         return True
     except Exception as e:
-        warn(f"[init] failed: {e}")
+        print(f"[init] failed: {e}")
         return False
 
-# ========= HF EndpointHandler =========
+# ===================== HF EndpointHandler =====================
+
 class EndpointHandler:
-    """Hugging Face Endpoint compatible."""
+    """Hugging Face Endpoint uyumlu sınıf"""
     def __init__(self, model_dir):
         self.model_dir = model_dir
         print(f"EndpointHandler initialized with model_dir: {model_dir}")
@@ -834,69 +474,4 @@ class EndpointHandler:
         return get_model_info()
 
 if __name__ == "__main__":
-    print("Handler ready (Deterministic JSON→Narrative with robust fallbacks, age+sex aware). Use `EndpointHandler` or `query`.")
-
-# ========= Optional FastAPI Wrapper =========
-try:
-    from fastapi import FastAPI
-    from pydantic import BaseModel
-    FASTAPI_AVAILABLE = True
-except Exception as e:
-    FASTAPI_AVAILABLE = False
-    warn(f"fastapi/pydantic not available: {e}")
-
-if FASTAPI_AVAILABLE:
-    app = FastAPI(title="PULSE ECG Handler API", version="1.4.0")
-
-    class QueryIn(BaseModel):
-        message: str | None = None
-        query: str | None = None
-        prompt: str | None = None
-        istem: str | None = None
-        image: str | Dict[str, Any] | None = None
-        image_url: str | None = None
-        img: str | None = None
-        temperature: float | None = None
-        top_p: float | None = None
-        max_output_tokens: int | None = None
-        max_new_tokens: int | None = None
-        max_tokens: int | None = None
-        repetition_penalty: float | None = None
-        conv_mode: str | None = None
-        det_seed: int | None = None
-        output_mode: str | None = None
-        patient_age_group: str | None = None
-        patient_sex: str | None = None
-
-    @app.on_event("startup")
-    async def _startup():
-        global model_initialized
-        if not model_initialized:
-            model_initialized = initialize_model()
-            print(f"[startup] model_initialized={model_initialized}")
-
-    @app.get("/health")
-    async def _health():
-        return health_check()
-
-    @app.get("/info")
-    async def _info():
-        return get_model_info()
-
-    @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 would fail if FastAPI is not installed
+    print("Handler ready (Demo Parity + Style Hint + whitespace post-process). Use `EndpointHandler` or `query`.")